@manahippo/aptos-wallet-adapter 0.4.3 → 0.4.4

package/src/WalletAdapters/FletchWallet.ts

@@ -0,0 +1,223 @@
+import { HexEncodedBytes, TransactionPayload } from 'aptos/src/generated';
+import {
+    WalletDisconnectionError,
+    WalletNotConnectedError,
+    WalletNotReadyError,
+    WalletSignAndSubmitMessageError,
+    WalletSignMessageError,
+    WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+    AccountKeys,
+    BaseWalletAdapter,
+    scopePollingDetectionStrategy,
+    SignMessagePayload,
+    SignMessageResponse,
+    WalletName,
+    WalletReadyState
+} from './BaseAdapter';
+
+interface IFletchWallet {
+    connect: () => Promise<{ Address: string; PublicKey: string, code: number, error?: any }>;
+    account: () => Promise<string>;
+    isConnected: () => Promise<boolean>;
+    signAndSubmitTransaction(transaction: any): Promise<{ code: number, error?: any, hash: string }>;
+    signTransaction(payload: any): Promise<{ code: number, error?: any, tx: Uint8Array }>;
+    signMessage(message: SignMessagePayload): Promise<{ code: number, error?: any, signedMessage: SignMessageResponse }>;
+    disconnect(): Promise<void>;
+}
+
+interface AptosWindow extends Window {
+    fletch?: IFletchWallet;
+}
+
+declare const window: AptosWindow;
+
+export const FletchWalletName = 'Fletch' as WalletName<'Fletch'>;
+
+export interface FletchWalletAdapterConfig {
+    provider?: IFletchWallet;
+    // network?: WalletAdapterNetwork;
+    timeout?: number;
+}
+
+export class FletchWalletAdapter extends BaseWalletAdapter {
+    name = FletchWalletName;
+
+    url = 'http://fletchwallet.io';
+
+    icon = 'http://fletchwallet.io/img/fletch-white.svg';
+
+    protected _provider: IFletchWallet;
+
+    // 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
+    }: FletchWalletAdapterConfig = {}) {
+        super();
+
+        this._provider = typeof window !== 'undefined' ? window.fletch : undefined;
+        // this._network = network;
+        this._timeout = timeout;
+        this._connecting = false;
+        this._wallet = null;
+
+        if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
+            scopePollingDetectionStrategy(() => {
+                if (window.fletch) {
+                    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 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.fletch;
+            const isConnected = await this._provider?.isConnected();
+            if (isConnected === true) {
+                await provider?.disconnect();
+            }
+
+            const response = await provider?.connect();
+            if (response.code != 200) {
+                throw response.error
+            }
+            this._wallet = {
+                address: response?.Address,
+                publicKey: response?.PublicKey,
+                isConnected: true
+            };
+
+            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.fletch;
+        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): Promise<Uint8Array> {
+        try {
+            const wallet = this._wallet;
+            const provider = this._provider || window.fletch;
+            if (!wallet || !provider) throw new WalletNotConnectedError();
+
+            const response = await provider.signTransaction(transaction);
+            if (response.code != 200) {
+                throw response.error
+            }
+            return response.tx;
+        } catch (error: any) {
+            const errMsg = error.message;
+            this.emit('error', new WalletSignTransactionError(errMsg));
+            throw error;
+        }
+    }
+
+    async signAndSubmitTransaction(
+        transaction: TransactionPayload
+    ): Promise<{ hash: HexEncodedBytes }> {
+        try {
+            const wallet = this._wallet;
+            const provider = this._provider || window.fletch;
+            if (!wallet || !provider) throw new WalletNotConnectedError();
+            const response = await provider.signAndSubmitTransaction(transaction);
+            if (response.code == 200) {
+                return { hash: response.hash };
+            }
+
+            throw response.error
+
+        } 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.fletch;
+            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.code == 200) {
+                return response.signedMessage;
+            }
+
+            throw response.error
+        } catch (error: any) {
+            const errMsg = error.message;
+            this.emit('error', new WalletSignMessageError(errMsg));
+            throw error;
+        }
+    }
+}

package/src/WalletAdapters/PetraWallet.ts

@@ -53,7 +53,8 @@ export interface AptosWalletAdapterConfig {
 export class AptosWalletAdapter extends BaseWalletAdapter {
   name = AptosWalletName;
 
-  url = 'https://aptos.dev/guides/building-wallet-extension';
+  url =
+    'https://chrome.google.com/webstore/detail/petra-aptos-wallet/ejjladinnckdgjemekebdpeokbikhfci';
 
   icon = 'https://miro.medium.com/fit/c/176/176/1*Gf747eyRywU8Img0tK5wvw.png';
 

package/src/WalletAdapters/PontemWallet.ts

@@ -12,6 +12,8 @@ import {
   AccountKeys,
   BaseWalletAdapter,
   scopePollingDetectionStrategy,
+  SignMessagePayload,
+  SignMessageResponse,
   WalletName,
   WalletReadyState
 } from './BaseAdapter';
@@ -45,11 +47,9 @@ interface IPontemWallet {
   }>;
   isConnected(): Promise<boolean>;
   signTransaction(transaction: TransactionPayload, options?: any): Promise<Uint8Array>;
-  signMessage(message: string): Promise<{
+  signMessage(message: SignMessagePayload): Promise<{
     success: boolean;
-    result: {
-      hexString: HexEncodedBytes;
-    };
+    result: SignMessageResponse;
   }>;
   disconnect(): Promise<void>;
 }
@@ -221,20 +221,19 @@ export class PontemWalletAdapter extends BaseWalletAdapter {
       }
       return { hash: response.result.hash };
     } catch (error: any) {
-      this.emit('error', new WalletSignAndSubmitMessageError(error.error.message));
+      this.emit('error', new WalletSignAndSubmitMessageError(error.message));
       throw error;
     }
   }
 
-  async signMessage(message: string): Promise<string> {
+  async signMessage(messagePayload: SignMessagePayload): Promise<SignMessageResponse> {
     try {
       const wallet = this._wallet;
       const provider = this._provider || window.pontem;
       if (!wallet || !provider) throw new WalletNotConnectedError();
-      const response = await provider?.signMessage(message);
-      console.log('MEMEM>>>', response);
+      const response = await provider?.signMessage(messagePayload);
       if (response.success) {
-        return response.result.hexString;
+        return response.result;
       } else {
         throw new Error('Sign Message failed');
       }

package/src/WalletAdapters/RiseWallet.ts

@@ -10,6 +10,8 @@ import {
   AccountKeys,
   BaseWalletAdapter,
   scopePollingDetectionStrategy,
+  SignMessagePayload,
+  SignMessageResponse,
   WalletName,
   WalletReadyState
 } from './BaseAdapter';
@@ -28,7 +30,7 @@ interface IRiseWallet {
   isConnected: () => Promise<boolean>;
   signAndSubmitTransaction(transaction: any): Promise<{ hash: HexEncodedBytes }>;
   signTransaction(transaction: any, options?: any): Promise<Uint8Array>;
-  signMessage(message: string): Promise<{ signature: string }>;
+  signMessage(message: SignMessagePayload): Promise<SignMessageResponse>;
   disconnect(): Promise<void>;
 }
 
@@ -213,20 +215,21 @@ export class RiseWalletAdapter extends BaseWalletAdapter {
     }
   }
 
-  async signMessage(message: string): Promise<string> {
+  async signMessage(msgPayload: SignMessagePayload): Promise<SignMessageResponse> {
     try {
       const wallet = this._wallet;
       const provider = this._provider || window.rise;
       if (!wallet || !provider) throw new WalletNotConnectedError();
-
-      const response = await provider?.signMessage(message);
-      if (response?.signature) {
-        return response.signature;
+      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) {
-      console.log('err', error);
       const errMsg = error.message;
       this.emit('error', new WalletSignMessageError(errMsg));
       throw error;

package/src/WalletAdapters/index.ts

@@ -9,3 +9,5 @@ export * from './PontemWallet';
 export * from './RiseWallet';
 export * from './SpikaWallet';
 export * from './HyperPayWallet';
+export * from './FletchWallet';
+export * from './AptosSnap';

package/src/WalletProviders/WalletProvider.tsx

@@ -105,6 +105,7 @@ export const WalletProvider: FC<WalletProviderProps> = ({
   useEffect(() => {
     const selectedWallet = wallets.find((wAdapter) => wAdapter.adapter.name === name);
     if (selectedWallet) {
+      console.log('selectedWallets', selectedWallet);
       setState({
         wallet: selectedWallet,
         adapter: selectedWallet.adapter,
@@ -180,14 +181,20 @@ 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 ||
-      !(readyState === WalletReadyState.Installed || readyState === WalletReadyState.Loadable)
-    )
+    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());
       return;
+    }
 
     (async function () {
       isConnecting.current = true;