feat: update aria extension entry

wallets/aria-extension/src/extension/client.ts

@@ -1,16 +1,24 @@
-import { chainRegistryChainToKeplr } from '@chain-registry/keplr';
-import { StdSignature, StdSignDoc } from '@cosmjs/amino';
-import { Algo, OfflineDirectSigner } from '@cosmjs/proto-signing';
+import {
+  AminoSignResponse,
+  OfflineAminoSigner,
+  StdSignDoc,
+  StdSignature,
+} from '@cosmjs/amino';
+import {
+  Algo,
+  DirectSignResponse,
+  OfflineDirectSigner,
+  OfflineSigner,
+} from '@cosmjs/proto-signing';
 import {
   BroadcastMode,
-  ChainRecord,
-  ExtendedHttpEndpoint,
+  DirectSignDoc,
+  SignOptions,
   SignType,
   SuggestToken,
+  WalletAccount,
+  WalletClient,
 } from '@cosmos-kit/core';
-import { DirectSignDoc, SignOptions, WalletClient } from '@cosmos-kit/core';
-import Long from 'long';
-
 import { Aria } from './types';
 
 export class AriaClient implements WalletClient {
@@ -29,14 +37,11 @@ export class AriaClient implements WalletClient {
     this._defaultSignOptions = options;
   }
 
-  constructor(client: Aria) {
+  constructor(client: any) {
+    if (!client) throw new Error('Aria client not initialized');
     this.client = client;
   }
 
-  async enable(chainIds: string | string[]) {
-    await this.client.enable(chainIds);
-  }
-
   async suggestToken({ chainId, tokens, type }: SuggestToken) {
     if (type === 'cw20') {
       for (const { contractAddress } of tokens) {
@@ -45,29 +50,6 @@ export class AriaClient implements WalletClient {
     }
   }
 
-  async addChain(chainInfo: ChainRecord) {
-    const suggestChain = chainRegistryChainToKeplr(
-      chainInfo.chain,
-      chainInfo.assetList ? [chainInfo.assetList] : []
-    );
-
-    if (chainInfo.preferredEndpoints?.rest?.[0]) {
-      (suggestChain.rest as string | ExtendedHttpEndpoint) =
-        chainInfo.preferredEndpoints?.rest?.[0];
-    }
-
-    if (chainInfo.preferredEndpoints?.rpc?.[0]) {
-      (suggestChain.rpc as string | ExtendedHttpEndpoint) =
-        chainInfo.preferredEndpoints?.rpc?.[0];
-    }
-
-    await this.client.experimentalSuggestChain(suggestChain);
-  }
-
-  async disconnect() {
-    await this.client.disconnect();
-  }
-
   async getSimpleAccount(chainId: string) {
     const { address, username } = await this.getAccount(chainId);
     return {
@@ -78,7 +60,7 @@ export class AriaClient implements WalletClient {
     };
   }
 
-  async getAccount(chainId: string) {
+  async getAccount(chainId: string): Promise<WalletAccount> {
     const key = await this.client.getKey(chainId);
     return {
       username: key.name,
@@ -89,32 +71,12 @@ export class AriaClient implements WalletClient {
     };
   }
 
-  getOfflineSigner(chainId: string, preferredSignType?: SignType) {
-    switch (preferredSignType) {
-      case 'amino':
-        return this.getOfflineSignerAmino(chainId);
-      case 'direct':
-        return this.getOfflineSignerDirect(chainId);
-      default:
-        return this.getOfflineSignerAmino(chainId);
-    }
-    // return this.client.getOfflineSignerAuto(chainId);
-  }
-
-  getOfflineSignerAmino(chainId: string) {
-    return this.client.getOfflineSignerOnlyAmino(chainId);
-  }
-
-  getOfflineSignerDirect(chainId: string) {
-    return this.client.getOfflineSigner(chainId) as OfflineDirectSigner;
-  }
-
   async signAmino(
     chainId: string,
     signer: string,
     signDoc: StdSignDoc,
     signOptions?: SignOptions
-  ) {
+  ): Promise<AminoSignResponse> {
     return await this.client.signAmino(
       chainId,
       signer,
@@ -136,19 +98,39 @@ export class AriaClient implements WalletClient {
     signer: string,
     signDoc: DirectSignDoc,
     signOptions?: SignOptions
-  ) {
+  ): Promise<DirectSignResponse> {
     return await this.client.signDirect(
       chainId,
       signer,
-      {
-        ...signDoc,
-        accountNumber: Long.fromString(signDoc.accountNumber.toString()),
-      },
+      signDoc,
       signOptions || this.defaultSignOptions
     );
   }
 
+  getOfflineSigner(
+    chainId: string,
+    preferredSignType?: SignType
+  ): OfflineSigner {
+    switch (preferredSignType) {
+      case 'amino':
+        return this.getOfflineSignerAmino(chainId);
+      case 'direct':
+        return this.getOfflineSignerDirect(chainId);
+      default:
+        return this.getOfflineSignerAmino(chainId);
+    }
+    // return this.client.getOfflineSignerAuto(chainId);
+  }
+
+  getOfflineSignerAmino(chainId: string): OfflineAminoSigner {
+    return this.client.getOfflineSignerOnlyAmino(chainId);
+  }
+
+  getOfflineSignerDirect(chainId: string): OfflineDirectSigner {
+    return this.client.getOfflineSigner(chainId) as OfflineDirectSigner;
+  }
+
   async sendTx(chainId: string, tx: Uint8Array, mode: BroadcastMode) {
-    return await this.client.sendTx(chainId, tx, mode);
+    return this.client.sendTx(chainId, tx, mode);
   }
 }

wallets/aria-extension/src/extension/registry.ts

@@ -1,14 +1,12 @@
 import { Wallet } from '@cosmos-kit/core';
-
 import { ICON } from '../constant';
 
 export const ariaExtensionInfo: Wallet = {
   name: 'aria-extension',
   prettyName: 'Aria',
   logo: ICON,
   mode: 'extension',
-  mobileDisabled: () =>
-    !('aria' in window || /AriaCosmos/i.test(navigator.userAgent)),
+  mobileDisabled: () => !('aria' in window),
   rejectMessage: {
     source: 'Request rejected',
   },

wallets/aria-extension/src/extension/types.ts

@@ -4,83 +4,61 @@ import {
   StdSignature,
   StdSignDoc,
 } from '@cosmjs/amino';
-import { OfflineDirectSigner, OfflineSigner } from '@cosmjs/proto-signing';
-import { DirectSignResponse } from '@cosmjs/proto-signing';
-import { BroadcastMode } from '@cosmos-kit/core';
-import type { ChainInfo } from '@keplr-wallet/types';
-
-export interface Key {
-  readonly name: string;
-  readonly algo: string;
-  readonly pubKey: Uint8Array;
-  readonly address: Uint8Array;
-  readonly bech32Address: string;
-  readonly isNanoLedger: boolean;
-}
-export interface AriaSignOptions {
-  readonly preferNoSetFee?: boolean;
-  readonly preferNoSetMemo?: boolean;
-  readonly disableBalanceCheck?: boolean;
-}
+import { DirectSignResponse, OfflineSigner } from '@cosmjs/proto-signing';
+import { BroadcastMode, DirectSignDoc, SignOptions } from '@cosmos-kit/core';
 
 export interface Aria {
-  defaultOptions: {
-    sign?: AriaSignOptions;
-  };
-  disconnect(): Promise<void>;
-  enable(chainIds: string | string[]): Promise<void>;
-  suggestToken(chainId: string, contractAddress: string): Promise<void>;
-  suggestCW20Token(chainId: string, contractAddress: string): Promise<void>;
-  mode: 'extension';
-  getKey(chainId: string): Promise<Key>;
-  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner;
-  getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner;
-  getOfflineSignerAuto(chainId: string): Promise<OfflineSigner>;
+  // Account Methods
+  getKey(chainId: string): Promise<{
+    name: string;
+    bech32Address: string;
+    algo: string;
+    pubKey: Uint8Array;
+    isNanoLedger: boolean;
+  }>;
+
+  // Signing Methods
   signAmino(
     chainId: string,
     signer: string,
     signDoc: StdSignDoc,
-    signOptions?: AriaSignOptions
+    signOptions?: SignOptions
   ): Promise<AminoSignResponse>;
+
   signDirect(
     chainId: string,
     signer: string,
-    signDoc: {
-      /** SignDoc bodyBytes */
-      bodyBytes?: Uint8Array | null;
-      /** SignDoc authInfoBytes */
-      authInfoBytes?: Uint8Array | null;
-      /** SignDoc chainId */
-      chainId?: string | null;
-      /** SignDoc accountNumber */
-      accountNumber?: Long | null;
-    },
-    signOptions?: AriaSignOptions
+    signDoc: DirectSignDoc,
+    signOptions?: SignOptions
   ): Promise<DirectSignResponse>;
+
   signArbitrary(
     chainId: string,
     signer: string,
     data: string | Uint8Array
   ): Promise<StdSignature>;
-  getEnigmaPubKey(chainId: string): Promise<Uint8Array>;
-  getEnigmaTxEncryptionKey(
-    chainId: string,
-    nonce: Uint8Array
-  ): Promise<Uint8Array>;
-  enigmaEncrypt(
-    chainId: string,
-    contractCodeHash: string,
-    msg: object
-  ): Promise<Uint8Array>;
-  enigmaDecrypt(
-    chainId: string,
-    ciphertext: Uint8Array,
-    nonce: Uint8Array
-  ): Promise<Uint8Array>;
+
+  // Transaction Methods
   sendTx(
     chainId: string,
     tx: Uint8Array,
     mode: BroadcastMode
   ): Promise<Uint8Array>;
-  experimentalSuggestChain(chainInfo: ChainInfo): Promise<void>;
+
+  // Signer Methods
+  getOfflineSigner(chainId: string): OfflineSigner;
+  getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner;
+
+  // Token Support
+  suggestCW20Token?(chainId: string, contractAddress: string): Promise<void>;
+
+  // Optional Methods (if used)
+  enable?(chainIds: string | string[]): Promise<void>;
+  disconnect?(): Promise<void>;
+}
+
+declare global {
+  interface Window {
+    aria?: Aria;
+  }
 }

wallets/aria-extension/src/extension/utils.ts

@@ -1,47 +1,28 @@
 import { ClientNotExistError } from '@cosmos-kit/core';
 
-import { Aria } from './types';
-
-interface AriaWindow {
-  aria?: Aria;
-}
-
-export const getAriaFromExtension: () => Promise<
-  Aria | undefined
-> = async () => {
+export const getAriaFromExtension = async () => {
   if (typeof window === 'undefined') {
-    return void 0;
+    return undefined;
   }
 
-  const aria = (window as AriaWindow).aria;
+  const aria = (window as any).aria;
 
   if (aria) {
     return aria;
   }
 
-  if (document.readyState === 'complete') {
-    if (aria) {
-      return aria;
-    } else {
-      throw ClientNotExistError;
-    }
-  }
-
   return new Promise((resolve, reject) => {
-    const documentStateChange = (event: Event) => {
-      if (
-        event.target &&
-        (event.target as Document).readyState === 'complete'
-      ) {
+    const checkReadyState = () => {
+      if (document.readyState === 'complete') {
+        const aria = (window as any).aria;
         if (aria) {
           resolve(aria);
         } else {
-          reject(ClientNotExistError.message);
+          reject(ClientNotExistError);
         }
-        document.removeEventListener('readystatechange', documentStateChange);
       }
     };
 
-    document.addEventListener('readystatechange', documentStateChange);
+    document.addEventListener('readystatechange', checkReadyState);
   });
 };