@manahippo/aptos-wallet-adapter 0.4.10 → 0.4.12

package/src/WalletAdapters/TokenPocketWallet.ts

@@ -0,0 +1,280 @@
+import { MaybeHexString } from 'aptos';
+import { TransactionPayload, HexEncodedBytes } from 'aptos/src/generated';
+import {
+    WalletDisconnectionError,
+    WalletNotConnectedError,
+    WalletGetNetworkError,
+    WalletNotReadyError,
+    WalletSignAndSubmitMessageError,
+    WalletSignMessageError,
+    WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+    AccountKeys,
+    BaseWalletAdapter,
+    NetworkInfo,
+    scopePollingDetectionStrategy,
+    SignMessagePayload,
+    SignMessageResponse,
+    WalletAdapterNetwork,
+    WalletName,
+    WalletReadyState
+} from './BaseAdapter';
+
+interface TokenPocketAccount {
+    address: MaybeHexString;
+    publicKey: MaybeHexString;
+}
+
+interface ITokenPocketWallet {
+    isTokenPocket: boolean;
+    connect: () => Promise<TokenPocketAccount>;
+    account: () => Promise<TokenPocketAccount>;
+    isConnected: () => Promise<boolean>;
+    signAndSubmitTransaction(
+        transaction: TransactionPayload,
+        options?: any
+    ): Promise<{ hash: HexEncodedBytes }>;
+    network: () => Promise<WalletAdapterNetwork>;
+    getChainId: () => Promise<string>;
+    getNodeUrl: () => Promise<string>;
+    signTransaction(transaction: TransactionPayload, options?: any): Promise<Uint8Array>;
+    signMessage(message: SignMessagePayload): Promise<SignMessageResponse>;
+    disconnect(): Promise<void>;
+    onAccountChange: (listener: (newAddress: TokenPocketAccount) => void) => void;
+    onNetworkChange: (listener: (network: { networkName: string }) => void) => void;
+}
+
+interface TokenPocketWindow extends Window {
+    aptos?: ITokenPocketWallet;
+}
+
+declare const window: TokenPocketWindow;
+
+export const TokenPocketWalletName = 'TokenPocket' as WalletName<'TokenPocket'>;
+
+export interface TokenPocketWalletAdapterConfig {
+    provider?: ITokenPocketWallet;
+    // network?: WalletAdapterNetwork;
+    timeout?: number;
+}
+
+export class TokenPocketWalletAdapter extends BaseWalletAdapter {
+    name = TokenPocketWalletName;
+
+    url = 'https://tokenpocket.pro';
+
+    icon = 'https://tp-statics.tokenpocket.pro/logo/tokenpocket.png';
+
+    protected _provider: ITokenPocketWallet | undefined;
+
+    protected _network: WalletAdapterNetwork;
+
+    protected _chainId: string;
+
+    protected _api: string;
+
+    // protected _network: WalletAdapterNetwork;
+    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.Mainnet,
+        timeout = 10000
+    }: TokenPocketWalletAdapterConfig = {}) {
+        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.aptos && window.aptos?.isTokenPocket) {
+                    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 isConnected = await provider?.isConnected();
+            if (isConnected) {
+                await provider?.disconnect();
+            }
+            const response = await provider?.connect();
+
+            if (!response) {
+                throw new WalletNotConnectedError('No connect response');
+            }
+
+            this._wallet = {
+                address: response?.address,
+                publicKey: response?.publicKey,
+                isConnected: true
+            };
+
+            try {
+                const network = await provider?.network();
+                const chainId = await provider?.getChainId();
+                const api = await provider?.getNodeUrl();
+
+                this._network = network;
+                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.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.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: 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) {
+                throw new Error('No response');
+            }
+            return response;
+        } catch (error: any) {
+            this.emit('error', new WalletSignTransactionError(error));
+            throw error;
+        }
+    }
+
+    async signAndSubmitTransaction(
+        transaction: TransactionPayload,
+        options?: any
+    ): Promise<{ hash: 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) {
+                throw new Error('No response');
+            }
+            return response as { hash: HexEncodedBytes };
+        } 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.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 onNetworkChange(): Promise<void> {
+
+    }
+
+    async onAccountChange(): Promise<void> {
+
+    }
+
+
+}

package/src/WalletAdapters/index.ts

@@ -11,3 +11,5 @@ export * from './SpikaWallet';
 export * from './HyperPayWallet';
 export * from './FletchWallet';
 export * from './AptosSnap';
+export * from './BitkeepWallet';
+export * from './TokenPocketWallet';

package/src/WalletProviders/WalletProvider.tsx

@@ -229,20 +229,14 @@ export const WalletProvider: FC<WalletProviderProps> = ({
 
   // If autoConnect is enabled, try to connect when the adapter changes and is ready
   useEffect(() => {
-    if (isConnecting.current || connected || !autoConnect || !adapter) return;
-
-    // Handle wallet not installed in Auto-connect mode
-    if (!(readyState === WalletReadyState.Installed || readyState === WalletReadyState.Loadable)) {
-      // Clear the selected wallet
-      setName(null);
-
-      if (typeof window !== 'undefined') {
-        window.open(adapter.url, '_blank');
-      }
-
-      handleError(new WalletNotReadyError());
+    if (
+      isConnecting.current ||
+      connected ||
+      !autoConnect ||
+      !adapter ||
+      !(readyState === WalletReadyState.Installed || readyState === WalletReadyState.Loadable)
+    )
       return;
-    }
 
     (async function () {
       isConnecting.current = true;
@@ -274,7 +268,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
         window.open(adapter.url, '_blank');
       }
 
-      throw handleError(new WalletNotReadyError());
+      throw handleError(new WalletNotReadyError('Wallet Not Ready'));
     }
     isConnecting.current = true;
     setConnecting(true);