@manahippo/aptos-wallet-adapter 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manahippo/aptos-wallet-adapter",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -31,8 +31,8 @@
     "@blocto/sdk": "^0.3.1",
     "@fewcha/web3": "0.1.32",
     "@keystonehq/aptossnap-adapter": "^0.2.8",
+    "@openblockhq/dappsdk": "^5.0.2",
     "eventemitter3": "^4.0.7",
-    "js-sha3": "^0.8.0",
-    "msafe-iframe": "^1.0.8"
+    "js-sha3": "^0.8.0"
   }
 }

package/src/WalletAdapters/BloctoWallet.ts

@@ -197,14 +197,13 @@ export class BloctoWalletAdapter extends BaseWalletAdapter {
   }
 
   async signAndSubmitTransaction(
-    transaction: Types.TransactionPayload
+    transaction: Types.TransactionPayload,
+    options?: any
   ): Promise<{ hash: Types.HexEncodedBytes }> {
     try {
       try {
         const provider = this._provider;
-        const response = await provider?.signAndSubmitTransaction(
-          transaction as Types.EntryFunctionPayload
-        );
+        const response = await provider?.signAndSubmitTransaction(transaction, options);
         if (response) {
           return { hash: response.hash };
         } else {

package/src/WalletAdapters/CloverWallet.ts

@@ -0,0 +1,274 @@
+import { 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 IApotsErrorResult {
+  code: number;
+  message: string;
+}
+
+type AddressInfo = { address: string; publicKey: string };
+
+interface ICloverWallet {
+  connect: () => Promise<AddressInfo>;
+  account: () => Promise<AddressInfo>;
+  isConnected: () => Promise<boolean>;
+  signAndSubmitTransaction(
+    transaction: any,
+    options?: any
+  ): Promise<{ hash: Types.HexEncodedBytes } | IApotsErrorResult>;
+  signTransaction(transaction: any, options?: any): Promise<Uint8Array | IApotsErrorResult>;
+  signMessage(message: SignMessagePayload): Promise<SignMessageResponse>;
+  disconnect(): Promise<void>;
+}
+
+interface AptosWindow extends Window {
+    clover_aptos:ICloverWallet;
+}
+
+declare const window: AptosWindow;
+
+export const CloverWalletName = 'Clover' as WalletName<'Clover'>;
+
+export interface CloverWalletAdapterConfig {
+  provider?: ICloverWallet;
+  network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class CloverWalletAdapter extends BaseWalletAdapter {
+  name = CloverWalletName;
+
+  url = 'https://chrome.google.com/webstore/detail/clv-wallet/nhnkbkgjikgcigadomkphalanndcapjk';
+
+  icon = 'https://raw.githubusercontent.com/clover-network/clv-network-token-lists/main/assets/clover.png';
+
+  protected _provider: ICloverWallet | 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: any | null;
+
+  constructor({
+    timeout = 10000
+  }: CloverWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = typeof window !== 'undefined' ? window.clover_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.clover_aptos) {
+          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.clover_aptos;
+      let response = await provider?.connect();
+
+      if (typeof response === 'boolean') {
+        response = await provider?.account();
+      }
+
+      this._wallet = {
+        address: response?.address,
+        publicKey: response?.publicKey,
+        isConnected: true
+      };
+
+      try {
+        const chainId = null;
+        const api = null;
+
+        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.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.clover_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: Types.TransactionPayload, options?: any): Promise<Uint8Array> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.clover_aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+
+      const response = await provider.signTransaction(transaction, options);
+      return response as Uint8Array;
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletSignTransactionError(errMsg));
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(
+    transaction: Types.TransactionPayload,
+    options?: any
+  ): Promise<{ hash: Types.HexEncodedBytes }> {
+    try {
+      const wallet = this._wallet;
+      const provider = this._provider || window.clover_aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+
+      const response = await provider.signAndSubmitTransaction(transaction, options);
+      return response as { hash: Types.HexEncodedBytes };
+    } 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.clover_aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      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.clover_aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      //To be implemented
+    } 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.clover_aptos;
+      if (!wallet || !provider) throw new WalletNotConnectedError();
+      //To be implemented
+    } catch (error: any) {
+      const errMsg = error.message;
+      this.emit('error', new WalletNetworkChangeError(errMsg));
+      throw error;
+    }
+  }
+}