@manahippo/aptos-wallet-adapter 1.0.2 → 1.0.3

package/src/WalletAdapters/FoxWallet.ts

@@ -0,0 +1,312 @@
+import { Types } from 'aptos';
+import {
+  WalletAccountChangeError,
+  WalletDisconnectionError,
+  WalletGetNetworkError,
+  WalletNetworkChangeError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageError,
+  WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+  AccountKeys,
+  BaseWalletAdapter,
+  NetworkInfo,
+  scopePollingDetectionStrategy,
+  SignMessagePayload,
+  SignMessageResponse,
+  WalletAdapterNetwork,
+  WalletName,
+  WalletReadyState
+} from './BaseAdapter';
+
+interface IApotsErrorResult {
+  code: number;
+  name: string;
+  message: string;
+}
+
+type AddressInfo = { address: string; publicKey: string; authKey?: string };
+
+interface IFoxWallet {
+  connect: () => Promise<AddressInfo>;
+  account: () => Promise<AddressInfo>;
+  isConnected: () => Promise<boolean>;
+  signAndSubmitTransaction(
+    transaction: any,
+    options?: any
+  ): Promise<{ hash: Types.HexEncodedBytes } | IApotsErrorResult>;
+  signTransaction(transaction: any, options?: any): Promise<Uint8Array | IApotsErrorResult>;
+  signMessage(message: SignMessagePayload): Promise<SignMessageResponse>;
+  disconnect(): Promise<void>;
+  network(): Promise<WalletAdapterNetwork>;
+  requestId: Promise<number>;
+  onAccountChange: (listener: (newAddress: AddressInfo) => void) => void;
+  onNetworkChange: (listener: (network: { networkName: string }) => void) => void;
+}
+
+interface AptosWindow extends Window {
+  foxwallet?: IFoxWallet;
+  aptos?: IFoxWallet;
+}
+
+declare const window: AptosWindow;
+
+export const FoxWalletName = 'FoxWallet' as WalletName<'FoxWallet'>;
+
+export interface FoxWalletAdapterConfig {
+  provider?: IFoxWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class FoxWalletAdapter extends BaseWalletAdapter {
+  name = FoxWalletName;
+
+  url = 'https://foxwallet.com';
+
+  icon =
+    'https://hc.foxwallet.com/assets/files/FoxWallet-logo-v4-9d2b5eec06bdd619c8678a8052dfc8da.svg';
+
+  protected _provider: IFoxWallet | undefined;
+
+  protected _network: WalletAdapterNetwork;
+
+  protected _chainId: string;
+
+  protected _api: string;
+
+  protected _timeout: number;
+
+  protected _readyState: WalletReadyState =
+    typeof window === 'undefined' || typeof document === 'undefined'
+      ? WalletReadyState.Unsupported
+      : WalletReadyState.NotDetected;
+
+  protected _connecting: boolean;
+
+  protected _wallet: any | null;
+
+  constructor({
+    // provider,
+    // network = WalletAdapterNetwork.Testnet,
+    timeout = 10000
+  }: FoxWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = typeof window !== 'undefined' ? window.aptos : undefined;
+    this._network = undefined;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        if (window.foxwallet && window.aptos) {
+          this._readyState = WalletReadyState.Installed;
+          this.emit('readyStateChange', this._readyState);
+          return true;
+        }
+        return false;
+      });
+    }
+  }
+
+  get publicAccount(): AccountKeys {
+    return {
+      publicKey: this._wallet?.publicKey || null,
+      address: this._wallet?.address || null,
+      authKey: this._wallet?.authKey || null
+    };
+  }
+
+  get network(): NetworkInfo {
+    return {
+      name: this._network,
+      api: this._api,
+      chainId: this._chainId
+    };
+  }
+
+  get connecting(): boolean {
+    return this._connecting;
+  }
+
+  get connected(): boolean {
+    return !!this._wallet?.isConnected;
+  }
+
+  get readyState(): WalletReadyState {
+    return this._readyState;
+  }
+
+  async connect(): Promise<void> {
+    try {
+      if (this.connected || this.connecting) return;
+      if (
+        !(
+          this._readyState === WalletReadyState.Loadable ||
+          this._readyState === WalletReadyState.Installed
+        )
+      )
+        throw new WalletNotReadyError();
+      this._connecting = true;
+
+      const provider = this._provider || window.aptos;
+      const response = await provider?.connect();
+      this._wallet = {
+        address: response?.address,
+        publicKey: response?.publicKey,
+        isConnected: true
+      };
+
+      try {
+        const name = await provider?.network();
+        const chainId = null;
+        const api = null;
+
+        this._network = name;
+        this._chainId = chainId;
+        this._api = api;
+      } catch (error: any) {
+        const errMsg = error.message;
+        this.emit('error', new WalletGetNetworkError(errMsg));
+        throw error;
+      }
+
+      this.emit('connect', this._wallet.publicKey);
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    } finally {
+      this._connecting = false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    const wallet = this._wallet;
+    const provider = this._provider || window.aptos;
+    if (wallet) {
+      this._wallet = null;
+
+      try {
+        await provider?.disconnect();
+      } catch (error: any) {
+        this.emit('error', new WalletDisconnectionError(error?.message, error));
+      }
+    }
+
+    this.emit('disconnect');
+  }
+
+  async signTransaction(transaction: Types.TransactionPayload, options?: any): Promise<Uint8Array> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+
+      const response = await provider.signTransaction(transaction, options);
+      if ((response as IApotsErrorResult).code) {
+        throw new Error((response as IApotsErrorResult).message);
+      }
+      return response as Uint8Array;
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignTransactionError(errMsg));
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(
+    transaction: Types.TransactionPayload,
+    options?: any
+  ): Promise<{ hash: Types.HexEncodedBytes }> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+
+      const response = await provider.signAndSubmitTransaction(transaction, options);
+      if ((response as IApotsErrorResult).code) {
+        throw new Error((response as IApotsErrorResult).message);
+      }
+      return response as { hash: Types.HexEncodedBytes };
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignAndSubmitMessageError(errMsg));
+      throw error;
+    }
+  }
+
+  async signMessage(msgPayload: SignMessagePayload): Promise<SignMessageResponse> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      if (typeof msgPayload !== 'object' || !msgPayload.nonce) {
+        throw new WalletSignMessageError('Invalid signMessage Payload');
+      }
+      const response = await provider?.signMessage(msgPayload);
+      if (response) {
+        return response;
+      } else {
+        throw new Error('Sign Message failed');
+      }
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignMessageError(errMsg));
+      throw error;
+    }
+  }
+
+  async onAccountChange(): Promise<void> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const handleAccountChange = async (newAccount: AddressInfo) => {
+        if (newAccount?.publicKey) {
+          this._wallet = {
+            ...this._wallet,
+            publicKey: newAccount.publicKey || this._wallet?.publicKey,
+            authKey: newAccount.authKey || this._wallet?.authKey,
+            address: newAccount.address || this._wallet?.address
+          };
+        } else {
+          const response = await provider?.connect();
+          this._wallet = {
+            ...this._wallet,
+            authKey: response?.authKey || this._wallet?.authKey,
+            address: response?.address || this._wallet?.address,
+            publicKey: response?.publicKey || this._wallet?.publicKey
+          };
+        }
+        this.emit('accountChange', newAccount.publicKey);
+      };
+      await provider?.onAccountChange(handleAccountChange);
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletAccountChangeError(errMsg));
+      throw error;
+    }
+  }
+
+  async onNetworkChange(): Promise<void> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const handleNetworkChange = async (newNetwork: { networkName: WalletAdapterNetwork }) => {
+        this._network = newNetwork.networkName;
+        this.emit('networkChange', this._network);
+      };
+      await provider?.onNetworkChange(handleNetworkChange);
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletNetworkChangeError(errMsg));
+      throw error;
+    }
+  }
+}

package/src/WalletAdapters/HyperPayWallet.ts

@@ -60,10 +60,10 @@ export interface HyperPayWalletAdapterConfig {
 export class HyperPayWalletAdapter extends BaseWalletAdapter {
   name = HyperPayWalletName;
 
-  url = 'https://www.hyperpay.tech/';
+  url = 'https://www.hyperpay.io/';
 
   icon =
-    'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMjE1IDEyMTUiPjxwYXRoIGQ9Ik02MDcuNSAwQzk0My4wMTMgMCAxMjE1IDI3MS45ODcgMTIxNSA2MDcuNVM5NDMuMDEzIDEyMTUgNjA3LjUgMTIxNSAwIDk0My4wMTMgMCA2MDcuNSAyNzEuOTg3IDAgNjA3LjUgMHpNMzUxLjY4IDM3MS4zMTVzMy43MDgtNzIuOSA3Ny43Ni03Mi45aDIwNC4xMnMxMTkuNDM3LS4xIDIwNC4xMiA3NS4zM2MwIDAgMTExLjg0MyA5My42MTIgMTE2LjY0IDIzNS43MSAwIDAgMS45NjIgMTE5LjA0NS03Mi45IDIxMS40MSAwIDAtNzcuOTMxIDEyMS41LTI2Mi40NCAxMjEuNUg0NDEuNTlzLTg5LjkxIDExLjA0OS04OS45MS04NS4wNXYtNDg2ek0xMTkuMzQ0IDU1My42NTlzLjkwNi0xNy44MiAxOS4wMDgtMTcuODJoNDkuOXMyOS4yLS4wMjMgNDkuOSAxOC40MTRjMCAwIDI3LjMzOSAyMi44ODMgMjguNTEyIDU3LjYxOCAwIDAgLjQ4IDI5LjEtMTcuODIgNTEuNjc4IDAgMC0xOS4wNSAyOS43LTY0LjE1MiAyOS43aC00My4zN3MtMjEuOTc4IDIuNy0yMS45NzgtMjAuNzl2LTExOC44eiIgZmlsbD0iIzE1N0VGQiIgZmlsbC1ydWxlPSJldmVub2RkIi8+PC9zdmc+';
+    'https://hyperpay.oss-ap-southeast-1.aliyuncs.com/heperpay/1666601839.png';
 
   protected _provider: IHyperPayWallet | undefined;
 

package/src/WalletAdapters/MsafeWallet.ts

@@ -0,0 +1,261 @@
+import { HexString, MaybeHexString, Types } from 'aptos';
+import {
+  WalletAccountChangeError,
+  WalletDisconnectionError,
+  WalletGetNetworkError,
+  WalletNetworkChangeError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageError,
+  WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+  AccountKeys,
+  BaseWalletAdapter,
+  NetworkInfo,
+  SignMessagePayload,
+  SignMessageResponse,
+  WalletAdapterNetwork,
+  WalletName,
+  WalletReadyState
+} from './BaseAdapter';
+import { Account, MsafeWallet } from 'msafe-iframe';
+
+export const MsafeWalletName = 'Msafe' as WalletName<'Msafe'>;
+
+interface MsafeAccount {
+  address: MaybeHexString;
+  publicKey: MaybeHexString;
+  authKey: MaybeHexString;
+  isConnected: boolean;
+}
+
+export class MsafeWalletAdapter extends BaseWalletAdapter {
+  name = MsafeWalletName;
+
+  url = 'https://app.m-safe.io';
+
+  icon = 'https://raw.githubusercontent.com/hippospace/aptos-wallet-adapter/main/logos/msafe.png';
+
+  protected _provider: MsafeWallet | undefined;
+
+  protected _network: WalletAdapterNetwork;
+
+  protected _chainId: string;
+
+  protected _api: string;
+
+  protected _readyState: WalletReadyState =
+    typeof window === 'undefined' || typeof document === 'undefined'
+      ? WalletReadyState.Unsupported
+      : WalletReadyState.NotDetected;
+
+  protected _connecting: boolean;
+
+  protected _wallet: MsafeAccount | null;
+
+  constructor(origin?: string) {
+    super();
+
+    this._network = undefined;
+    this._connecting = false;
+    MsafeWallet.new(origin)
+      .then((msafe) => {
+        this._provider = msafe;
+        this._readyState = WalletReadyState.Installed;
+        this.emit('readyStateChange', this._readyState);
+      })
+      .catch((e) => console.log(e));
+  }
+
+  get publicAccount(): AccountKeys {
+    return {
+      publicKey: this._wallet?.publicKey || null,
+      address: this._wallet?.address || null,
+      authKey: this._wallet?.authKey || null
+    };
+  }
+
+  get network(): NetworkInfo {
+    return {
+      name: this._network,
+      chainId: this._chainId
+    };
+  }
+
+  get connecting(): boolean {
+    return this._connecting;
+  }
+
+  get connected(): boolean {
+    return !!this._wallet?.isConnected;
+  }
+
+  get readyState(): WalletReadyState {
+    return this._readyState;
+  }
+
+  async connect(): Promise<void> {
+    try {
+      if (this.connected || this.connecting) return;
+      if (
+        !(
+          this._readyState === WalletReadyState.Loadable ||
+          this._readyState === WalletReadyState.Installed
+        )
+      )
+        throw new WalletNotReadyError();
+      this._connecting = true;
+
+      const provider = this._provider;
+      const isConnected = await provider?.isConnected();
+      if (isConnected) {
+        await provider?.disconnect();
+      }
+      const response = await provider?.connect();
+
+      if (!response) {
+        throw new WalletNotConnectedError('No connect response');
+      }
+
+      const walletAccount = await provider?.account();
+      if (walletAccount) {
+        this._wallet = {
+          ...walletAccount,
+          isConnected: true
+        } as any;
+
+        try {
+          const name = await provider?.network();
+          const chainId = await provider?.chainId();
+
+          this._network = name as WalletAdapterNetwork;
+          this._chainId = chainId.toString();
+        } catch (error: any) {
+          const errMsg = error.message;
+          this.emit('error', new WalletGetNetworkError(errMsg));
+          throw error;
+        }
+      }
+      this.emit('connect', this._wallet?.address || '');
+    } catch (error: any) {
+      this.emit('error', new Error(error));
+      throw error;
+    } finally {
+      this._connecting = false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    const wallet = this._wallet;
+    const provider = this._provider;
+    if (wallet) {
+      this._wallet = null;
+
+      try {
+        await provider?.disconnect();
+      } catch (error: any) {
+        this.emit('error', new WalletDisconnectionError(error?.message, error));
+      }
+    }
+
+    this.emit('disconnect');
+  }
+
+  async signTransaction(
+    transactionPyld: Types.TransactionPayload,
+    options?: any
+  ): Promise<Uint8Array> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const response = await provider.signTransaction(transactionPyld as any, options);
+
+      if (!response) {
+        throw new Error('No response');
+      }
+      return response;
+    } catch (error: any) {
+      this.emit('error', new WalletSignTransactionError(error));
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(
+    transactionPyld: Types.TransactionPayload,
+    options?: any
+  ): Promise<{ hash: Types.HexEncodedBytes }> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const response = await provider.signAndSubmit(transactionPyld as any, options);
+
+      if (!response) {
+        throw new Error('No response');
+      }
+      return { hash: HexString.fromUint8Array(response).hex() };
+    } catch (error: any) {
+      this.emit('error', new WalletSignAndSubmitMessageError(error));
+      throw error;
+    }
+  }
+
+  async signMessage(msgPayload: SignMessagePayload): Promise<SignMessageResponse> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const response = await provider.signMessage(msgPayload as any);
+      if (response) {
+        return response as any;
+      } else {
+        throw new Error('Sign Message failed');
+      }
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignMessageError(errMsg));
+      throw error;
+    }
+  }
+
+  async onAccountChange(): Promise<void> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const handleChangeAccount = async (newAccount: Account) => {
+        this._wallet = {
+          ...this._wallet,
+          ...newAccount
+        };
+        this.emit('accountChange', newAccount.address);
+      };
+      provider.onChangeAccount(handleChangeAccount);
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletAccountChangeError(errMsg));
+      throw error;
+    }
+  }
+
+  async onNetworkChange(): Promise<void> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const handleNetworkChange = async (newNetwork: WalletAdapterNetwork) => {
+        this._network = newNetwork;
+        this._chainId = (await this._provider.chainId()).toString();
+        this.emit('networkChange', this._network);
+      };
+      provider.onChangeNetwork(handleNetworkChange);
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletNetworkChangeError(errMsg));
+      throw error;
+    }
+  }
+}

package/src/WalletAdapters/NightlyWallet.ts

@@ -124,13 +124,13 @@ export class NightlyWalletAdapter extends BaseWalletAdapter {
   }: NightlyWalletAdapterConfig = {}) {
     super();
 
-    this._provider = window.nightly?.aptos;
+    this._provider = typeof window !== 'undefined' ? window.nightly?.aptos : undefined;
     this._network = undefined;
     this._timeout = timeout;
     this._connecting = false;
     this._wallet = null;
 
-    if (this._readyState !== WalletReadyState.Unsupported) {
+    if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
       scopePollingDetectionStrategy(() => {
         if (window.nightly?.aptos) {
           this._readyState = WalletReadyState.Installed;

package/src/WalletAdapters/SpikaWallet.ts

@@ -51,7 +51,7 @@ export class SpikaWalletAdapter extends BaseWalletAdapter {
 
   url = 'https://chrome.google.com/webstore/detail/spika/fadkojdgchhfkdkklllhcphknohbmjmb';
 
-  icon = 'https://spika.app/assets/logo_400_nb.png';
+  icon = 'https://raw.githubusercontent.com/hippospace/aptos-wallet-adapter/main/logos/spika.svg';
 
   protected _provider: ISpikaWallet | undefined;
 

package/src/WalletAdapters/index.ts

@@ -17,3 +17,5 @@ export * from './ONTOWallet';
 export * from './BloctoWallet';
 export * from './Coin98Wallet';
 export * from './SafePalWallet';
+export * from './FoxWallet';
+export * from './MsafeWallet';