@manahippo/aptos-wallet-adapter 0.1.1

package/src/WalletAdatpers/HippoWallet.ts

@@ -0,0 +1,183 @@
+import { MaybeHexString } from 'aptos';
+import {
+  PendingTransaction,
+  SubmitTransactionRequest,
+  TransactionPayload
+} from 'aptos/dist/api/data-contracts';
+import { WEBWALLET_URL } from '../config/aptosConstants';
+import {
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignAndSubmitMessageError
+} from '../WalletProviders/errors';
+import { BaseWalletAdapter, PublicKey, WalletName, WalletReadyState } from './BaseAdapter';
+
+export const HippoWalletName = 'Hippo Wallet' as WalletName<'Hippo Wallet'>;
+
+export interface HippoWalletAdapterConfig {
+  provider?: string;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class HippoWalletAdapter extends BaseWalletAdapter {
+  name = HippoWalletName;
+
+  url = 'https://hippo-wallet-test.web.app';
+
+  icon = 'https://ui-test1-22e7c.web.app/static/media/hippo_logo.ecded6bf411652de9b7f.png';
+
+  protected _provider: string | undefined;
+
+  // protected _network: WalletAdapterNetwork;
+  protected _timeout: number;
+
+  protected _readyState: WalletReadyState = WalletReadyState.Installed;
+
+  protected _connecting: boolean;
+
+  protected _wallet: any | null;
+
+  constructor({
+    // provider = WEBWALLET_URL,
+    // network = WalletAdapterNetwork.Mainnet,
+    timeout = 10000
+  }: HippoWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = WEBWALLET_URL || 'https://hippo-wallet-test.web.app';
+    // this._network = network;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+    this._readyState = WalletReadyState.Installed;
+  }
+
+  get publicKey(): PublicKey | null {
+    return this._wallet?.publicKey || null;
+  }
+
+  get connecting(): boolean {
+    return this._connecting;
+  }
+
+  get connected(): boolean {
+    return !!this._wallet?.connected;
+  }
+
+  get readyState(): WalletReadyState {
+    return this._readyState;
+  }
+
+  handleMessage = (
+    e: MessageEvent<{
+      id: number;
+      method: string;
+      address?: {
+        hexString: MaybeHexString;
+      };
+      error?: string;
+    }>
+  ): void => {
+    if (e.origin === this._provider) {
+      if (e.data.method === 'account') {
+        this._wallet = {
+          connected: true,
+          publicKey: e.data.address?.hexString || null
+        };
+        this.emit('connect', this._wallet.publicKey);
+      } else if (e.data.method === 'success') {
+        this.emit('success', 'Transaction Success');
+      } else if (e.data.method === 'fail') {
+        this.emit('error', new WalletSignAndSubmitMessageError(e.data.error));
+      } else if (e.data.method === 'disconnected') {
+        this.disconnect();
+      }
+    }
+  };
+
+  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;
+
+      window.addEventListener('message', this.handleMessage);
+      window.addEventListener('beforeunload', this._beforeUnload);
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    } finally {
+      this._connecting = false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    window.removeEventListener('message', this.handleMessage);
+    window.removeEventListener('beforeunload', this._beforeUnload);
+    this.emit('disconnect');
+  }
+
+  async signTransaction(transaction: TransactionPayload): Promise<SubmitTransactionRequest> {
+    try {
+      const request = new URLSearchParams({
+        request: JSON.stringify({
+          method: 'signTransaction',
+          payload: transaction
+        }),
+        origin: window.location.origin
+      }).toString();
+      const popup = window.open(
+        `${WEBWALLET_URL}?${request}`,
+        'Transaction Confirmation',
+        'scrollbars=no,resizable=no,status=no,location=no,toolbar=no,menubar=no,width=440,height=700'
+      );
+      if (!popup) throw new WalletNotConnectedError();
+      const promise = await new Promise((resolve, reject) => {
+        this.once('success', resolve);
+        this.once('error', reject);
+      });
+      return promise as SubmitTransactionRequest;
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(transaction: TransactionPayload): Promise<PendingTransaction> {
+    try {
+      const request = new URLSearchParams({
+        request: JSON.stringify({
+          method: 'signAndSubmit',
+          payload: transaction
+        }),
+        origin: window.location.origin
+      }).toString();
+      const popup = window.open(
+        `${WEBWALLET_URL}?${request}`,
+        'Transaction Confirmation',
+        'scrollbars=no,resizable=no,status=no,location=no,toolbar=no,menubar=no,width=440,height=700'
+      );
+      if (!popup) throw new WalletNotConnectedError();
+      const promise = await new Promise((resolve, reject) => {
+        this.once('success', resolve);
+        this.once('error', reject);
+      });
+      return promise as PendingTransaction;
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  private _beforeUnload = (): void => {
+    void this.disconnect();
+  };
+}

package/src/WalletAdatpers/MartianWallet.ts

@@ -0,0 +1,237 @@
+import {
+  PendingTransaction,
+  ScriptFunctionPayload,
+  SubmitTransactionRequest,
+  TransactionPayload
+} from 'aptos/dist/api/data-contracts';
+import {
+  WalletDisconnectionError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+  BaseWalletAdapter,
+  PublicKey,
+  scopePollingDetectionStrategy,
+  WalletName,
+  WalletReadyState
+} from './BaseAdapter';
+
+interface IMartianWallet {
+  connect: (params?: any) => Promise<any>;
+  publicKey?: string;
+  isConnected?: boolean;
+  signGenericTransaction(transaction: any): Promise<void>;
+  // signTransaction(transaction: any): Promise<void>;
+  disconnect(): Promise<void>;
+}
+
+interface MartianWindow extends Window {
+  aptos?: IMartianWallet;
+}
+
+declare const window: MartianWindow;
+
+export const MartianWalletName = 'MartianWallet' as WalletName<'MartianWallet'>;
+
+export interface MartianWalletAdapterConfig {
+  provider?: IMartianWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class MartianWalletAdapter extends BaseWalletAdapter {
+  name = MartianWalletName;
+
+  url = 'https://chrome.google.com/webstore/detail/martian-wallet/efbglgofoippbgcjepnhiblaibcnclgk';
+
+  icon =
+    'https://www.gitbook.com/cdn-cgi/image/width=40,height=40,fit=contain,dpr=2,format=auto/https%3A%2F%2F1159842905-files.gitbook.io%2F~%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FXillBNDwQOz0oPJ4OtRH%252Ficon%252FaBwgf6d32iEu3YE56Jvk%252Flogo128_squ.png%3Falt%3Dmedia%26token%3D0f5bef1f-a4bd-495e-a447-289c235bb76a';
+
+  protected _provider: IMartianWallet | 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
+  }: MartianWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = window.aptos;
+    // this._network = network;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        if (window.aptos) {
+          this._readyState = WalletReadyState.Installed;
+          this.emit('readyStateChange', this._readyState);
+          return true;
+        }
+        return false;
+      });
+    }
+  }
+
+  get publicKey(): PublicKey | null {
+    return this._wallet?.publicKey || 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 {
+      // console.log(1);
+      if (this.connected || this.connecting) return;
+      // console.log(2);
+      if (
+        !(
+          this._readyState === WalletReadyState.Loadable ||
+          this._readyState === WalletReadyState.Installed
+        )
+      )
+        throw new WalletNotReadyError();
+      // console.log(3);
+      this._connecting = true;
+
+      const provider = window.aptos;
+      // console.log(4);
+      const loggedInAddress = await new Promise<string>((resolve, reject) => {
+        provider?.disconnect();
+        // console.log(5);
+        provider?.connect((respAddress: string) => {
+          // console.log(6);
+          try {
+            resolve(respAddress);
+          } catch (err) {
+            reject(err);
+          }
+          // 0xc4265dc8a5d90715f8a60bebf16688819427bca928a537ad35f798d4d1267716
+        });
+      });
+      // console.log(7, loggedInAddress, window.aptos?.publicKey);
+      if (loggedInAddress === window.aptos?.publicKey) {
+        // console.log(8);
+        this._wallet = window.aptos;
+      }
+      // console.log(9);
+      this.emit('connect', this._wallet.publicKey);
+    } catch (error: any) {
+      // console.log(10, error);
+      this.emit('error', error);
+      throw error;
+    } finally {
+      // console.log(11);
+      this._connecting = false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    const wallet = this._wallet;
+    if (wallet) {
+      this._wallet = null;
+
+      try {
+        await new Promise<void>((resolve, reject) => {
+          const timeout = setTimeout(() => resolve(), 250);
+
+          try {
+            wallet.disconnect(() => {
+              clearTimeout(timeout);
+              resolve();
+            });
+          } catch (err) {
+            reject(err);
+          }
+        });
+      } 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;
+      if (!wallet) throw new WalletNotConnectedError();
+
+      try {
+        const response = await new Promise<SubmitTransactionRequest>((resolve, reject) => {
+          wallet.signGenericTransaction(transaction, (resp: any) => {
+            // console.log('signTransaction', resp);
+            if (resp.status === 200) {
+              // console.log('Transaction is Signed successfully.');
+              resolve(resp);
+            } else {
+              reject(resp.message);
+            }
+          });
+        });
+        return response;
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error?.message, error);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(tempTransaction: TransactionPayload): Promise<PendingTransaction> {
+    try {
+      const wallet = this._wallet;
+      if (!wallet) throw new WalletNotConnectedError();
+      const transaction = tempTransaction as ScriptFunctionPayload;
+
+      try {
+        // console.log('trans', 1);
+        const response = await new Promise<PendingTransaction>((resolve, reject) => {
+          // const args = [...transaction.type_arguments, transaction.arguments[0] / 1000];
+          // console.log('trans 2', wallet, transaction, args);
+          wallet.signGenericTransaction(transaction.type, transaction.arguments, (resp: any) => {
+            // console.log('signTransaction', resp);
+            if (resp.status === 200) {
+              // console.log('Transaction is Signed successfully.');
+              resolve(resp);
+            } else {
+              reject(resp.message);
+            }
+          });
+        });
+        return response;
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+}

package/src/WalletAdatpers/MultiMaskWallet.ts

@@ -0,0 +1,240 @@
+import {
+  PendingTransaction,
+  ScriptFunctionPayload,
+  SubmitTransactionRequest,
+  TransactionPayload
+} from 'aptos/dist/api/data-contracts';
+import {
+  WalletDisconnectionError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletSignTransactionError
+} from '../WalletProviders/errors';
+import {
+  BaseWalletAdapter,
+  PublicKey,
+  scopePollingDetectionStrategy,
+  WalletName,
+  WalletReadyState
+} from './BaseAdapter';
+
+interface IMultiMaskWallet {
+  currentProvider: {
+    enable: () => Promise<PublicKey[]>;
+    sendAsync(payload: any, callback: (error: Error | null, result?: any) => void): void;
+  };
+  request: (params?: any) => Promise<any>;
+  publicKey?: string;
+  isConnected?: boolean;
+  signGenericTransaction(transaction: any): Promise<void>;
+  // signTransaction(transaction: any): Promise<void>;
+  disconnect(): Promise<void>;
+}
+
+interface MultiMaskWindow extends Window {
+  aptosWeb3?: IMultiMaskWallet;
+}
+
+declare const window: MultiMaskWindow;
+
+export const MultiMaskWalletName = 'MultiMaskWallet' as WalletName<'MultiMaskWallet'>;
+
+export interface MultiMaskWalletAdapterConfig {
+  provider?: IMultiMaskWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class MultiMaskWalletAdapter extends BaseWalletAdapter {
+  name = MultiMaskWalletName;
+
+  url = 'https://github.com/pontem-network/aptos-chrome-extension/releases';
+
+  icon = 'https://liquidswap.pontem.network/img/logo.87454209.svg';
+
+  protected _provider: IMultiMaskWallet | 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
+  }: MultiMaskWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = window.aptosWeb3;
+    // this._network = network;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        if (this._provider) {
+          this._readyState = WalletReadyState.Installed;
+          this.emit('readyStateChange', this._readyState);
+          return true;
+        }
+        return false;
+      });
+    }
+  }
+
+  get publicKey(): PublicKey | null {
+    return this._wallet?.publicKey || 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 {
+      // console.log(1);
+      if (this.connected || this.connecting) return;
+      // console.log(2);
+      if (
+        !(
+          this._readyState === WalletReadyState.Loadable ||
+          this._readyState === WalletReadyState.Installed
+        )
+      )
+        throw new WalletNotReadyError();
+      // console.log(3);
+      this._connecting = true;
+
+      const provider = this._provider;
+      // console.log(4);
+
+      const wallets = await provider?.currentProvider.enable();
+      if (wallets && wallets.length) {
+        this._wallet = {
+          publicKey: wallets[0],
+          isConnected: true
+        };
+        // console.log(9, this._wallet);
+        this.emit('connect', this._wallet);
+      }
+    } catch (error: any) {
+      // console.log(10, error);
+      this.emit('error', error);
+      throw error;
+    } finally {
+      // console.log(11);
+      this._connecting = false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    const wallet = this._wallet;
+    if (wallet) {
+      this._wallet = null;
+
+      try {
+        await new Promise<void>((resolve, reject) => {
+          const timeout = setTimeout(() => resolve(), 250);
+
+          try {
+            wallet.disconnect(() => {
+              clearTimeout(timeout);
+              resolve();
+            });
+          } catch (err) {
+            reject(err);
+          }
+        });
+      } 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;
+      if (!wallet) throw new WalletNotConnectedError();
+
+      try {
+        const response = await new Promise<SubmitTransactionRequest>((resolve, reject) => {
+          wallet.signGenericTransaction(transaction, (resp: any) => {
+            // console.log('signTransaction', resp);
+            if (resp.status === 200) {
+              // console.log('Transaction is Signed successfully.');
+              resolve(resp);
+            } else {
+              reject(resp.message);
+            }
+          });
+        });
+        return response;
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error?.message, error);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(tempTransaction: TransactionPayload): Promise<PendingTransaction> {
+    try {
+      const wallet = this._provider;
+      if (!wallet) throw new WalletNotConnectedError();
+      const transaction = tempTransaction as ScriptFunctionPayload;
+
+      try {
+        // console.log('trans', 1);
+        const response = await new Promise<PendingTransaction>((resolve, reject) => {
+          // const args = [...transaction.type_arguments, transaction.arguments[0] / 1000];
+          // console.log('trans 2', transaction, transaction.function.split(':')[0]);
+          wallet.currentProvider.sendAsync(
+            {
+              method: 'eth_sendTransaction',
+              params: [{ from: transaction.function.split(':')[0] }]
+            },
+            (error, resp: any) => {
+              console.log('signTransaction', error, resp);
+              if (error) {
+                reject(error.message);
+              } else {
+                resolve(resp);
+              }
+              // if (resp.status === 200) {
+              //   // console.log('Transaction is Signed successfully.');
+              // } else {
+              //   reject(resp.message);
+              // }
+            }
+          );
+        });
+        return response;
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+}

package/src/WalletAdatpers/index.ts

@@ -0,0 +1,6 @@
+export * from './AptosWallet';
+export * from './BaseAdapter';
+export * from './HippoExtensionWallet';
+export * from './HippoWallet';
+export * from './MartianWallet';
+export * from './MultiMaskWallet';