@manahippo/aptos-wallet-adapter 1.0.1 → 1.0.3

package/src/WalletAdapters/SafePalWallet.ts

@@ -0,0 +1,319 @@
+import { MaybeHexString, 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 ConnectSafePalAccount {
+  address: MaybeHexString;
+  method: string;
+  publicKey: MaybeHexString;
+  status: number;
+}
+
+interface SafePalAccount {
+  address: MaybeHexString;
+  publicKey: MaybeHexString;
+  authKey: MaybeHexString;
+  isConnected: boolean;
+}
+interface ISafePalWallet {
+  connect: () => Promise<ConnectSafePalAccount>;
+  account(): Promise<SafePalAccount>;
+  isConnected(): Promise<boolean>;
+  generateTransaction(sender: MaybeHexString, payload: any, options?: any): Promise<any>;
+  signAndSubmitTransaction(transaction: Types.TransactionPayload): Promise<Types.HexEncodedBytes>;
+  signTransaction(transaction: Types.TransactionPayload): Promise<Uint8Array>;
+  signMessage(message: SignMessagePayload): Promise<SignMessageResponse>;
+  disconnect(): Promise<void>;
+  getChainId(): Promise<{ chainId: number }>;
+  network(): Promise<WalletAdapterNetwork>;
+  onAccountChange: (listenr: (newAddress: string) => void) => void;
+  onNetworkChange: (listenr: (network: string) => void) => void;
+}
+
+interface SafePalWindow extends Window {
+  safePal?: ISafePalWallet;
+}
+
+declare const window: SafePalWindow;
+
+export const SafePalWalletName = 'SafePal' as WalletName<'SafePal'>;
+
+export interface SafePalWalletAdapterConfig {
+  provider?: ISafePalWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class SafePalWalletAdapter extends BaseWalletAdapter {
+  name = SafePalWalletName;
+
+  url = 'https://chrome.google.com/webstore/detail/safepal-extension-wallet/lgmpcpglpngdoalbgeoldeajfclnhafa';
+
+  icon = 'https://raw.githubusercontent.com/hippospace/aptos-wallet-adapter/main/logos/safePal.png';
+
+  protected _provider: ISafePalWallet | 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: SafePalAccount | null;
+
+  constructor({
+    // provider,
+    // network = WalletAdapterNetwork.Testnet,
+    timeout = 10000
+  }: SafePalWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = typeof window !== 'undefined' ? window.safePal : undefined;
+    this._network = undefined;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        this._provider = typeof window !== 'undefined' ? window.safePal : undefined;
+        if (this._provider) {
+          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.safePal;
+      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
+        };
+
+        try {
+          const name = await provider?.network();
+          const { chainId } = await provider?.getChainId();
+          const api = null;
+
+          this._network = name;
+          this._chainId = chainId.toString();
+          this._api = api;
+        } 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 || window.safePal;
+    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 || window.safePal;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const tx = await provider.generateTransaction(wallet.address || '', transactionPyld, options);
+      if (!tx) throw new Error('Cannot generate transaction');
+      const response = await provider?.signTransaction(tx);
+
+      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 || window.safePal;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const tx = await provider.generateTransaction(wallet.address || '', transactionPyld, options);
+      if (!tx) throw new Error('Cannot generate transaction');
+      const response = await provider?.signAndSubmitTransaction(tx);
+
+      if (!response) {
+        throw new Error('No response');
+      }
+      return { hash: response };
+    } 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 || window.safePal;
+      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.safePal;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const handleChangeAccount = async (newAccount: string) => {
+        const { publicKey } = await provider?.account();
+        this._wallet = {
+          ...this._wallet,
+          address: newAccount,
+          publicKey
+        };
+        this.emit('accountChange', newAccount);
+      };
+      await provider?.onAccountChange(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 || window.safePal;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const handleNetworkChange = async (newNetwork: WalletAdapterNetwork) => {
+        this._network = newNetwork;
+        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/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

@@ -15,3 +15,7 @@ export * from './BitkeepWallet';
 export * from './TokenPocketWallet';
 export * from './ONTOWallet';
 export * from './BloctoWallet';
+export * from './Coin98Wallet';
+export * from './SafePalWallet';
+export * from './FoxWallet';
+export * from './MsafeWallet';

package/src/WalletProviders/WalletProvider.tsx

@@ -1,10 +1,14 @@
 import { FC, ReactNode, useCallback, useEffect, useRef, useState } from 'react';
 import { Types } from 'aptos';
 import {
+  WalletConnectionError,
   WalletError,
   WalletNotConnectedError,
   WalletNotReadyError,
-  WalletNotSelectedError
+  WalletNotSelectedError,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageError,
+  WalletSignTransactionError
 } from './errors';
 import { useLocalStorage } from '../hooks/useLocalStorage';
 import {
@@ -16,6 +20,7 @@ import {
   WalletReadyState
 } from '../WalletAdapters/BaseAdapter';
 import { Wallet, WalletContext } from './useWallet';
+import { timeoutPromise } from '../utilities/util';
 
 export interface WalletProviderProps {
   children: ReactNode;
@@ -39,6 +44,8 @@ const initialState: {
   network: null
 };
 
+const TIMEOUT = 90;
+
 export const WalletProvider: FC<WalletProviderProps> = ({
   children,
   wallets: adapters,
@@ -117,6 +124,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
 
     window.addEventListener('beforeunload', listener);
     return () => window.removeEventListener('beforeunload', listener);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [isUnloading, autoConnect]);
 
   // Handle the adapter's connect event
@@ -261,12 +269,17 @@ export const WalletProvider: FC<WalletProviderProps> = ({
       isConnecting.current = true;
       setConnecting(true);
       try {
-        await walletToConnect.adapter.connect();
+        const timeout = timeoutPromise(TIMEOUT * 1000);
+        await Promise.race([walletToConnect.adapter.connect(), timeout.promise]);
+        clearTimeout(timeout.timeoutId);
       } catch (error: any) {
         // Clear the selected wallet
         setName(null);
-        // Rethrow the error, and handleError will also be called
-        throw error;
+        if (error === 'timeout') {
+          throw handleError(new WalletConnectionError(error));
+        } else {
+          throw error;
+        }
       } finally {
         setConnecting(false);
         isConnecting.current = false;
@@ -314,7 +327,13 @@ export const WalletProvider: FC<WalletProviderProps> = ({
     async (transaction: Types.TransactionPayload, option?: any) => {
       if (!adapter) throw handleError(new WalletNotSelectedError());
       if (!connected) throw handleError(new WalletNotConnectedError());
-      const response = await adapter.signAndSubmitTransaction(transaction, option);
+      const timeout = timeoutPromise(TIMEOUT * 1000);
+      const response = await Promise.race([
+        adapter.signAndSubmitTransaction(transaction, option),
+        timeout.promise
+      ]);
+      clearTimeout(timeout.timeoutId);
+      if (!response) throw handleError(new WalletSignAndSubmitMessageError('Timeout'));
       return response;
     },
     [adapter, handleError, connected]
@@ -324,7 +343,14 @@ export const WalletProvider: FC<WalletProviderProps> = ({
     async (transaction: Types.TransactionPayload, option?: any) => {
       if (!adapter) throw handleError(new WalletNotSelectedError());
       if (!connected) throw handleError(new WalletNotConnectedError());
-      return adapter.signTransaction(transaction, option);
+      const timeout = timeoutPromise(TIMEOUT * 1000);
+      const response = await Promise.race([
+        adapter.signTransaction(transaction, option),
+        timeout.promise
+      ]);
+      clearTimeout(timeout.timeoutId);
+      if (!response) throw handleError(new WalletSignTransactionError('Timeout'));
+      return response;
     },
     [adapter, handleError, connected]
   );
@@ -333,7 +359,11 @@ export const WalletProvider: FC<WalletProviderProps> = ({
     async (msgPayload: string | SignMessagePayload | Uint8Array) => {
       if (!adapter) throw handleError(new WalletNotSelectedError());
       if (!connected) throw handleError(new WalletNotConnectedError());
-      return adapter.signMessage(msgPayload);
+      const timeout = timeoutPromise(TIMEOUT * 1000);
+      const response = await Promise.race([adapter.signMessage(msgPayload), timeout.promise]);
+      clearTimeout(timeout.timeoutId);
+      if (!response) throw handleError(new WalletSignMessageError('Timeout'));
+      return response;
     },
     [adapter, handleError, connected]
   );

package/src/utilities/util.ts

@@ -9,3 +9,16 @@ export const payloadV1ToV0 = (payload: Types.TransactionPayload) => {
     arguments: v1.arguments
   };
 };
+
+export const timeoutPromise = (timeout) => {
+  let timeoutId;
+  const promise: Promise<void> = new Promise((resolve, reject) => {
+    timeoutId = setTimeout(async () => {
+      reject('timeout');
+    }, timeout);
+  });
+  return {
+    timeoutId,
+    promise
+  };
+};