@manahippo/aptos-wallet-adapter 0.2.0 → 0.3.1

package/src/WalletAdapters/PontemWallet.ts

@@ -0,0 +1,250 @@
+import { MaybeHexString } from 'aptos';
+import {
+  TransactionPayload,
+  SubmitTransactionRequest,
+  HexEncodedBytes
+} from 'aptos/dist/generated';
+import {
+  WalletDisconnectionError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageError,
+  WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+  AccountKeys,
+  BaseWalletAdapter,
+  scopePollingDetectionStrategy,
+  WalletName,
+  WalletReadyState
+} from './BaseAdapter';
+
+interface ConnectPontemAccount {
+  address: MaybeHexString;
+  method: string;
+  publicKey: MaybeHexString;
+  status: number;
+}
+
+interface PontemAccount {
+  address: MaybeHexString;
+  publicKey?: MaybeHexString;
+  authKey?: MaybeHexString;
+  isConnected: boolean;
+}
+interface IPontemWallet {
+  connect: () => Promise<ConnectPontemAccount>;
+  account(): Promise<MaybeHexString>;
+  generateTransaction(sender: MaybeHexString, payload: any): Promise<any>;
+  signAndSubmit(
+    transaction: TransactionPayload,
+    options?: any
+  ): Promise<{
+    success: boolean;
+    result: {
+      hash: HexEncodedBytes;
+    };
+  }>;
+  // signTransaction(transaction: TransactionPayload): Promise<HexEncodedBytes>;
+  signMessage(message: string): Promise<string>;
+  disconnect(): Promise<void>;
+}
+
+interface PontemWindow extends Window {
+  pontem?: IPontemWallet;
+}
+
+declare const window: PontemWindow;
+
+export const PontemWalletName = 'Pontem' as WalletName<'Pontem'>;
+
+export interface PontemWalletAdapterConfig {
+  provider?: IPontemWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class PontemWalletAdapter extends BaseWalletAdapter {
+  name = PontemWalletName;
+
+  url = 'https://chrome.google.com/webstore/detail/pontem-wallet/phkbamefinggmakgklpkljjmgibohnba';
+
+  icon =
+    'https://www.gitbook.com/cdn-cgi/image/width=20,height=20,fit=contain,dpr=2,format=auto/https%3A%2F%2F736486047-files.gitbook.io%2F~%2Ffiles%2Fv0%2Fb%2Fgitbook-legacy-files%2Fo%2Fspaces%252F-MVVJKmKQGx983dZy_jr%252Favatar-1619180126965.png%3Fgeneration%3D1619180127194239%26alt%3Dmedia';
+
+  protected _provider: IPontemWallet | undefined;
+
+  // protected _network: WalletAdapterNetwork;
+  protected _timeout: number;
+
+  protected _readyState: WalletReadyState =
+    typeof window === 'undefined' || typeof document === 'undefined'
+      ? WalletReadyState.Unsupported
+      : WalletReadyState.NotDetected;
+
+  protected _connecting: boolean;
+
+  protected _wallet: PontemAccount | null;
+
+  constructor({
+    // provider,
+    // network = WalletAdapterNetwork.Mainnet,
+    timeout = 10000
+  }: PontemWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = typeof window !== 'undefined' ? window.pontem : undefined;
+    // this._network = network;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        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 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.pontem;
+      // 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 = {
+          address: walletAccount,
+          isConnected: true
+        };
+      }
+      this.emit('connect', this._wallet?.address || '');
+    } catch (error: any) {
+      this.emit('error', new Error('User has rejected the connection'));
+      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(): Promise<SubmitTransactionRequest> {
+    try {
+      // const wallet = this._wallet;
+      // const provider = this._provider || window.pontem;
+      // if (!wallet || !provider) throw new WalletNotConnectedError();
+      // const tx = await provider.generateTransaction(
+      //   wallet.address || '',
+      //   payloadV1ToV0(transactionPyld)
+      // );
+      // if (!tx) throw new WalletSignTransactionError('Cannot generate transaction');
+      // const response = await provider?.signTransaction(tx);
+
+      // if (!response) {
+      //   throw new WalletSignTransactionError('No response');
+      // }
+      // const result = { hash: response } as any;
+      return {} as SubmitTransactionRequest;
+    } catch (error: any) {
+      this.emit('error', new WalletSignTransactionError(error));
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(
+    transactionPyld: TransactionPayload,
+    options?: any
+  ): Promise<{ hash: HexEncodedBytes }> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.pontem;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const response = await provider?.signAndSubmit(transactionPyld, options);
+
+      if (!response || !response.success) {
+        throw new Error('No response');
+      }
+      return { hash: response.result.hash };
+    } catch (error: any) {
+      this.emit('error', new WalletSignAndSubmitMessageError(error.error.message));
+      throw error;
+    }
+  }
+
+  async signMessage(message: string): Promise<string> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.pontem;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const response = await provider?.signMessage(message);
+      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;
+    }
+  }
+}

package/src/WalletAdapters/SpikaWallet.ts

@@ -0,0 +1,229 @@
+import {
+  HexEncodedBytes,
+  SubmitTransactionRequest,
+  TransactionPayload
+} from 'aptos/dist/generated';
+import {
+  WalletDisconnectionError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageError,
+  WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+  AccountKeys,
+  BaseWalletAdapter,
+  scopePollingDetectionStrategy,
+  WalletName,
+  WalletReadyState
+} from './BaseAdapter';
+
+interface ISpikaWallet {
+  connect: () => Promise<{ publicKey: string; account: string; authKey: string }>;
+  account: () => Promise<string>;
+  isConnected: () => Promise<boolean>;
+  signAndSubmitTransaction(transaction: any): Promise<{ hash: HexEncodedBytes }>;
+  signTransaction(transaction: any): Promise<SubmitTransactionRequest>;
+  signMessage(message: string): Promise<string>;
+  disconnect(): Promise<void>;
+}
+
+interface SpikaWindow extends Window {
+  spika?: ISpikaWallet;
+}
+
+declare const window: SpikaWindow;
+
+export const SpikaWalletName = 'Spika' as WalletName<'Spika'>;
+
+export interface SpikaWalletAdapterConfig {
+  provider?: ISpikaWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class SpikaWalletAdapter extends BaseWalletAdapter {
+  name = SpikaWalletName;
+
+  url = 'https://chrome.google.com/webstore/detail/spika/fadkojdgchhfkdkklllhcphknohbmjmb';
+
+  icon = 'https://pbs.twimg.com/profile_images/1562544739181887488/vSqEIeyh_400x400.png';
+
+  protected _provider: ISpikaWallet | undefined;
+
+  // 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
+  }: SpikaWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = typeof window !== 'undefined' ? window.spika : undefined;
+    // this._network = network;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (typeof window !== 'undefined' && this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        if (window.spika) {
+          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.spika;
+      const isConnected = await this._provider?.isConnected();
+      if (isConnected === true) {
+        await provider?.disconnect();
+      }
+
+      const response = await provider?.connect();
+      if (response?.publicKey !== undefined) {
+        this._wallet = {
+          publicKey: response?.publicKey,
+          address: response?.account,
+          authKey: response?.authKey,
+          isConnected: true
+        };
+      } else {
+        this._wallet = {
+          isConnected: false
+        };
+      }
+
+      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;
+    if (wallet) {
+      this._wallet = null;
+
+      try {
+        const provider = this._provider || window.spika;
+        await provider?.disconnect();
+      } catch (error: any) {
+        this.emit('error', new WalletDisconnectionError(error?.message, error));
+      }
+    }
+
+    this.emit('disconnect');
+  }
+
+  async signTransaction(transaction: TransactionPayload): Promise<SubmitTransactionRequest> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.spika;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+
+      const response = await provider?.signTransaction(transaction);
+      if (response) {
+        return response;
+      } else {
+        throw new Error('Sign Transaction failed');
+      }
+    } 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.spika;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+
+      const response = await provider?.signAndSubmitTransaction(transaction);
+      if (response) {
+        return response;
+      } else {
+        throw new Error('Transaction failed');
+      }
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignAndSubmitMessageError(errMsg));
+      throw error;
+    }
+  }
+
+  async signMessage(message: string): Promise<string> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.spika;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      const response = await provider?.signMessage(message);
+      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;
+    }
+  }
+}

package/src/WalletAdapters/index.ts

@@ -3,6 +3,7 @@ export * from './BaseAdapter';
 export * from './HippoExtensionWallet';
 export * from './HippoWallet';
 export * from './MartianWallet';
-export * from './MultiMaskWallet';
 export * from './FewchaWallet';
-export * from './NightlyWallet';
+export * from './PontemWallet';
+// export * from './NightlyWallet';
+export * from './SpikaWallet';

package/src/WalletProviders/WalletProvider.tsx

@@ -1,6 +1,6 @@
-import { TransactionPayload } from 'aptos/dist/api/data-contracts';
 import { useLocalStorage } from '../hooks/useLocalStorage';
 import { FC, ReactNode, useCallback, useEffect, useRef, useState } from 'react';
+import { TransactionPayload } from 'aptos/dist/generated';
 import {
   WalletError,
   WalletNotConnectedError,
@@ -9,7 +9,6 @@ import {
 } from './errors';
 import {
   AccountKeys,
-  PublicKey,
   WalletAdapter,
   WalletName,
   WalletReadyState
@@ -19,7 +18,6 @@ import { Wallet, WalletContext } from './useWallet';
 export interface WalletProviderProps {
   children: ReactNode;
   wallets: WalletAdapter[];
-  autoConnect?: boolean;
   onError?: (error: WalletError) => void;
   localStorageKey?: string;
 }
@@ -39,7 +37,6 @@ const initialState: {
 export const WalletProvider: FC<WalletProviderProps> = ({
   children,
   wallets: adapters,
-  autoConnect = false,
   onError,
   localStorageKey = 'walletName'
 }) => {
@@ -141,7 +138,6 @@ export const WalletProvider: FC<WalletProviderProps> = ({
         adapter.off('error', handleError);
       };
     }
-    return () => null;
   }, [adapter, handleConnect, handleDisconnect, handleError]);
 
   // When the adapter changes, disconnect the old one
@@ -241,10 +237,18 @@ export const WalletProvider: FC<WalletProviderProps> = ({
     [adapter, handleError, connected]
   );
 
+  const signMessage = useCallback(
+    async (message: string) => {
+      if (!adapter) throw handleError(new WalletNotSelectedError());
+      if (!connected) throw handleError(new WalletNotConnectedError());
+      return adapter.signMessage(message);
+    },
+    [adapter, handleError, connected]
+  );
+
   return (
     <WalletContext.Provider
       value={{
-        autoConnect,
         wallets,
         wallet,
         account,
@@ -255,10 +259,8 @@ export const WalletProvider: FC<WalletProviderProps> = ({
         connect,
         disconnect,
         signAndSubmitTransaction,
-        // sendTransaction,
-        signTransaction
-        // signAllTransactions,
-        // signMessage
+        signTransaction,
+        signMessage
       }}>
       {children}
     </WalletContext.Provider>

package/src/WalletProviders/useWallet.ts

@@ -1,12 +1,11 @@
 import {
-  PendingTransaction,
+  TransactionPayload,
   SubmitTransactionRequest,
-  TransactionPayload
-} from 'aptos/dist/api/data-contracts';
+  HexEncodedBytes
+} from 'aptos/dist/generated';
 import { createContext, useContext } from 'react';
 import {
   AccountKeys,
-  PublicKey,
   WalletAdapter,
   WalletName,
   WalletReadyState
@@ -18,7 +17,7 @@ export interface Wallet {
 }
 
 export interface WalletContextState {
-  autoConnect: boolean;
+  // autoConnect: boolean;
   wallets: Wallet[];
   wallet: Wallet | null;
   account: AccountKeys | null;
@@ -28,19 +27,13 @@ export interface WalletContextState {
   select(walletName: WalletName): void;
   connect(walletName: string): Promise<void>;
   disconnect(): Promise<void>;
-  signAndSubmitTransaction(
-    transaction: TransactionPayload
-    // connection: Connection,
-    // options?: SendTransactionOptions
-  ): Promise<PendingTransaction>;
-
+  signAndSubmitTransaction(transaction: TransactionPayload): Promise<{ hash: HexEncodedBytes }>;
   signTransaction(transaction: TransactionPayload): Promise<SubmitTransactionRequest>;
-  // signAllTransactions: SignerWalletAdapterProps['signAllTransactions'] | undefined;
-  // signMessage: MessageSignerWalletAdapterProps['signMessage'] | undefined;
+  signMessage(message: string): Promise<string>;
 }
 
 const DEFAULT_CONTEXT = {
-  autoConnect: false,
+  // autoConnect: false,
   connecting: false,
   connected: false,
   disconnecting: false

package/src/config/aptosConstants.ts

@@ -4,7 +4,7 @@ export const WEBWALLET_URL = 'https://hippo-wallet-test.web.app';
 // export const WEBWALLET_URL = 'http://localhost:3030';
 
 export const LOCAL_NODE_URL = 'http://127.0.0.1:8080';
-export const DEVNET_NODE_URL = 'https://fullnode.devnet.aptoslabs.com';
+export const DEVNET_NODE_URL = 'https://fullnode.devnet.aptoslabs.com/v1';
 export const LOCAL_FAUCET_URL = 'http://127.0.0.1:8000';
 export const DEVNET_FAUCET_URL = 'https://faucet.devnet.aptoslabs.com';
 

package/src/hooks/useLocalStorage.ts

@@ -1,15 +1,20 @@
 import { useCallback, useState } from 'react';
+import { useSSR } from './useSSR';
 
 export const useLocalStorage = () => {
+  const { isClient } = useSSR();
   const useLocalStorageState = <T>(
     key: string,
     defaultState: T,
     session?: boolean
   ): [T, (T: any) => void] => {
-    const storage = session ? sessionStorage : localStorage;
+    let storage: undefined | Storage;
+    if (isClient) {
+      storage = session ? sessionStorage : localStorage;
+    }
     const [state, setState] = useState(() => {
       try {
-        let storedState = storage.getItem(key);
+        let storedState = storage?.getItem(key);
         if (storedState) {
           return JSON.parse(storedState || '');
         }
@@ -25,9 +30,9 @@ export const useLocalStorage = () => {
       (newState: any) => {
         setState(newState);
         if (newState === null) {
-          storage.removeItem(key);
+          storage?.removeItem(key);
         } else {
-          storage.setItem(key, JSON.stringify(newState));
+          storage?.setItem(key, JSON.stringify(newState));
         }
       },
       [key, storage]

package/src/hooks/useSSR.ts

@@ -0,0 +1,15 @@
+import { useEffect, useState } from 'react';
+
+export const useSSR = () => {
+  const [isClient, setIsClient] = useState(false);
+
+  useEffect(() => {
+    if (typeof window !== 'undefined') {
+      setIsClient(true);
+    }
+  }, []);
+
+  return {
+    isClient
+  };
+};

package/src/utilities/util.ts

@@ -0,0 +1,11 @@
+import { TransactionPayload, TransactionPayload_EntryFunctionPayload } from 'aptos/dist/generated';
+
+export const payloadV1ToV0 = (payload: TransactionPayload) => {
+  const v1 = payload as TransactionPayload_EntryFunctionPayload;
+  return {
+    type: 'script_function_payload',
+    function: v1.function,
+    type_arguments: v1.type_arguments,
+    arguments: v1.arguments
+  };
+};