@manahippo/aptos-wallet-adapter 0.1.1

package/.eslintignore

@@ -0,0 +1,6 @@
+node_modules/
+build/
+public/
+craco.config.js
+tailwind.config.js
+postcss.config.js

package/.eslintrc.json

@@ -0,0 +1,52 @@
+{
+  "root": true,
+  "env": {
+    "browser": true,
+    "es2021": true
+  },
+  "settings": {
+    "import/resolver": {
+      "node": {
+        "extensions": [".js", ".ts", ".tsx"]
+      }
+    },
+    "import/extensions": [".js", ".ts", ".tsx"]
+  },
+  "extends": [
+    "plugin:react/recommended",
+    "plugin:react-hooks/recommended",
+    "plugin:prettier/recommended",
+    "airbnb-typescript"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaFeatures": {
+      "jsx": true
+    },
+    "ecmaVersion": 12,
+    "sourceType": "module",
+    "project": "./tsconfig.json"
+  },
+  "plugins": ["import", "react", "@typescript-eslint", "prettier"],
+  "ignorePatterns": ["src/**/*.svg", "**/node_modules/**"],
+  "rules": {
+    "consistent-return": 0,
+    "function-paren-newline": 0,
+    "object-curly-newline": 0,
+    "react/prop-types": 0,
+    "react/jsx-filename-extension": 0,
+    "react/react-in-jsx-scope": 0,
+    "react/jsx-one-expression-per-line": 0,
+    "react/jsx-props-no-spreading": 0,
+    "react/jsx-closing-bracket-location": 0,
+    "react/no-unescaped-entities": 0,
+    "import/prefer-default-export": 0,
+    "implicit-arrow-linebreak": 0,
+    "jest/no-mocks-import": 0,
+    "prettier/prettier": "error",
+    "no-unused-vars": ["error", { "vars": "all", "args": "none", "ignoreRestSiblings": true }],
+    "@typescript-eslint/comma-dangle": 0,
+    "@typescript-eslint/no-use-before-define": 0,
+    "@typescript-eslint/indent": 0
+  }
+}

package/.prettierrc.json

@@ -0,0 +1,9 @@
+{
+  "trailingComma": "none",
+  "semi": true,
+  "tabWidth": 2,
+  "singleQuote": true,
+  "bracketSpacing": true,
+  "bracketSameLine": true,
+  "printWidth": 100
+}

package/README.md

@@ -0,0 +1 @@
+# aptos-wallet-adapter

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@manahippo/aptos-wallet-adapter",
+  "version": "0.1.1",
+  "scripts": {
+    "build": "rm -rf dist; tsc -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "react": "^18.1.0",
+    "react-dom": "^18.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^27.0.1",
+    "@types/node": "^16.7.13",
+    "@types/react": "^18.0.0",
+    "aptos": "^0.0.20",
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react": "^7.30.1",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eventemitter3": "^4.0.7",
+    "prettier": "^2.7.1",
+    "typescript": "^4.7.4"
+  }
+}

package/src/WalletAdatpers/AptosWallet.ts

@@ -0,0 +1,194 @@
+import {
+  PendingTransaction,
+  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 IAptosWallet {
+  requestId: number;
+  connect: () => Promise<{ address: string }>;
+  account: () => Promise<string>;
+  isConnected: () => Promise<boolean>;
+  signAndSubmitTransaction(transaction: any): Promise<void>;
+  signTransaction(transaction: any): Promise<void>;
+  disconnect(): Promise<void>;
+}
+
+interface AptosWindow extends Window {
+  aptos?: IAptosWallet;
+}
+
+declare const window: AptosWindow;
+
+export const AptosWalletName = 'Aptos Wallet' as WalletName<'Aptos Wallet'>;
+
+export interface AptosWalletAdapterConfig {
+  provider?: IAptosWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class AptosWalletAdapter extends BaseWalletAdapter {
+  name = AptosWalletName;
+
+  url = 'https://aptos.dev/guides/building-wallet-extension';
+
+  icon = 'https://miro.medium.com/fit/c/176/176/1*Gf747eyRywU8Img0tK5wvw.png';
+
+  protected _provider: IAptosWallet | 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
+  }: AptosWalletAdapterConfig = {}) {
+    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 {
+      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 response = await provider?.connect();
+
+      this._wallet = {
+        publicKey: response?.address,
+        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;
+    if (wallet) {
+      this._wallet = null;
+
+      try {
+        const provider = this._provider || window.aptos;
+        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;
+      if (!wallet) throw new WalletNotConnectedError();
+
+      try {
+        const provider = this._provider || window.aptos;
+        const response = await provider?.signTransaction(transaction);
+        if (response) {
+          return response;
+        } else {
+          throw new Error('Transaction failed');
+        }
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error?.message, error);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(transaction: TransactionPayload): Promise<PendingTransaction> {
+    try {
+      const wallet = this._wallet;
+      if (!wallet) throw new WalletNotConnectedError();
+
+      try {
+        const provider = this._provider || window.aptos;
+        const response = await provider?.signAndSubmitTransaction(transaction);
+        if (response) {
+          return response;
+        } else {
+          throw new Error('Transaction failed');
+        }
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error.message);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+}

package/src/WalletAdatpers/BaseAdapter.ts

@@ -0,0 +1,148 @@
+import { MaybeHexString } from 'aptos';
+import {
+  PendingTransaction,
+  SubmitTransactionRequest,
+  TransactionPayload
+} from 'aptos/dist/api/data-contracts';
+import EventEmitter from 'eventemitter3';
+
+declare global {
+  interface Window {
+    hippo: any;
+  }
+}
+
+export { EventEmitter };
+
+export type PublicKey = MaybeHexString;
+
+export interface WalletAdapterEvents {
+  connect(publicKey: PublicKey): void;
+  disconnect(): void;
+  error(error: any): void;
+  success(value: any): void;
+  readyStateChange(readyState: WalletReadyState): void;
+}
+
+export enum WalletReadyState {
+  /**
+   * User-installable wallets can typically be detected by scanning for an API
+   * that they've injected into the global context. If such an API is present,
+   * we consider the wallet to have been installed.
+   */
+  Installed = 'Installed',
+  NotDetected = 'NotDetected',
+  /**
+   * Loadable wallets are always available to you. Since you can load them at
+   * any time, it's meaningless to say that they have been detected.
+   */
+  Loadable = 'Loadable',
+  /**
+   * If a wallet is not supported on a given platform (eg. server-rendering, or
+   * mobile) then it will stay in the `Unsupported` state.
+   */
+  Unsupported = 'Unsupported'
+}
+
+export type WalletName<T extends string = string> = T & { __brand__: 'WalletName' };
+
+export interface WalletAdapterProps<Name extends string = string> {
+  name: WalletName<Name>;
+  url: string;
+  icon: string;
+  readyState: WalletReadyState;
+  publicKey: PublicKey | null;
+  connecting: boolean;
+  connected: boolean;
+
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  signAndSubmitTransaction(
+    transaction: TransactionPayload
+    // connection: Connection,
+    // options?: SendTransactionOptions
+  ): Promise<PendingTransaction>;
+  signTransaction(
+    transaction: TransactionPayload
+    // connection: Connection,
+    // options?: SendTransactionOptions
+  ): Promise<SubmitTransactionRequest>;
+}
+
+export type WalletAdapter<Name extends string = string> = WalletAdapterProps<Name> &
+  EventEmitter<WalletAdapterEvents>;
+
+export interface SignerWalletAdapterProps {
+  // signTransaction(transaction: Transaction): Promise<Transaction>;
+  // signAllTransactions(transaction: Transaction[]): Promise<Transaction[]>;
+}
+
+export abstract class BaseWalletAdapter
+  extends EventEmitter<WalletAdapterEvents>
+  implements WalletAdapter
+{
+  abstract name: WalletName;
+
+  abstract url: string;
+
+  abstract icon: string;
+
+  abstract get readyState(): WalletReadyState;
+
+  abstract get publicKey(): PublicKey | null;
+
+  abstract get connecting(): boolean;
+
+  get connected(): boolean {
+    return !!this.publicKey;
+  }
+
+  abstract connect(): Promise<void>;
+  abstract disconnect(): Promise<void>;
+  abstract signAndSubmitTransaction(transaction: TransactionPayload): Promise<PendingTransaction>;
+
+  abstract signTransaction(transaction: TransactionPayload): Promise<SubmitTransactionRequest>;
+}
+
+export function scopePollingDetectionStrategy(detect: () => boolean): void {
+  // Early return when server-side rendering
+  if (typeof window === 'undefined' || typeof document === 'undefined') return;
+
+  const disposers: (() => void)[] = [];
+
+  function detectAndDispose() {
+    const detected = detect();
+    if (detected) {
+      for (const dispose of disposers) {
+        dispose();
+      }
+    }
+  }
+
+  // Strategy #1: Try detecting every second.
+  const interval =
+    // TODO: #334 Replace with idle callback strategy.
+    setInterval(detectAndDispose, 1000);
+  disposers.push(() => clearInterval(interval));
+
+  // Strategy #2: Detect as soon as the DOM becomes 'ready'/'interactive'.
+  if (
+    // Implies that `DOMContentLoaded` has not yet fired.
+    document.readyState === 'loading'
+  ) {
+    document.addEventListener('DOMContentLoaded', detectAndDispose, { once: true });
+    disposers.push(() => document.removeEventListener('DOMContentLoaded', detectAndDispose));
+  }
+
+  // Strategy #3: Detect after the `window` has fully loaded.
+  if (
+    // If the `complete` state has been reached, we're too late.
+    document.readyState !== 'complete'
+  ) {
+    window.addEventListener('load', detectAndDispose, { once: true });
+    disposers.push(() => window.removeEventListener('load', detectAndDispose));
+  }
+
+  // Strategy #4: Detect synchronously, now.
+  detectAndDispose();
+}

package/src/WalletAdatpers/HippoExtensionWallet.ts

@@ -0,0 +1,194 @@
+import {
+  PendingTransaction,
+  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 IHippoWallet {
+  connect: () => Promise<{ address: string }>;
+  account: () => Promise<string>;
+  isConnected: () => Promise<boolean>;
+  signAndSubmitTransaction(transaction: any): Promise<void>;
+  signTransaction(transaction: any): Promise<void>;
+  disconnect(): Promise<void>;
+}
+
+interface HippoWindow extends Window {
+  hippoWallet?: IHippoWallet;
+}
+
+declare const window: HippoWindow;
+
+export const HippoExtensionWalletName =
+  'Hippo Extension Wallet' as WalletName<'Hippo Extension Wallet'>;
+
+export interface HippoExtensionWalletAdapterConfig {
+  provider?: IHippoWallet;
+  // network?: WalletAdapterNetwork;
+  timeout?: number;
+}
+
+export class HippoExtensionWalletAdapter extends BaseWalletAdapter {
+  name = HippoExtensionWalletName;
+
+  url = 'https://hippo-wallet-test.web.app';
+
+  icon = 'https://ui-test1-22e7c.web.app/static/media/hippo_logo.ecded6bf411652de9b7f.png';
+
+  protected _provider: IHippoWallet | 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
+  }: HippoExtensionWalletAdapterConfig = {}) {
+    super();
+
+    this._provider = window.hippoWallet;
+    // this._network = network;
+    this._timeout = timeout;
+    this._connecting = false;
+    this._wallet = null;
+
+    if (this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        if (window.hippoWallet) {
+          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 {
+      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.hippoWallet;
+      const response = await provider?.connect();
+
+      this._wallet = {
+        publicKey: response?.address,
+        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;
+    if (wallet) {
+      this._wallet = null;
+
+      try {
+        const provider = this._provider || window.hippoWallet;
+        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;
+      if (!wallet) throw new WalletNotConnectedError();
+
+      try {
+        const provider = this._provider || window.hippoWallet;
+        const response = await provider?.signTransaction(transaction);
+        if (response) {
+          return response;
+        } else {
+          throw new Error('Transaction failed');
+        }
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error?.message, error);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  async signAndSubmitTransaction(transaction: TransactionPayload): Promise<PendingTransaction> {
+    try {
+      const wallet = this._wallet;
+      if (!wallet) throw new WalletNotConnectedError();
+
+      try {
+        const provider = this._provider || window.hippoWallet;
+        const response = await provider?.signAndSubmitTransaction(transaction);
+        if (response) {
+          return response;
+        } else {
+          throw new Error('Transaction failed');
+        }
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error.message);
+      }
+    } catch (error: any) {
+      this.emit('error', error);
+      throw error;
+    }
+  }
+}