@aptos-labs/wallet-adapter-core 0.1.3

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["adapter"],
+};

package/README.md

@@ -0,0 +1,3 @@
+# Aptos Wallet Adapter core functionality
+
+The core functionality for the wallet adapter that holds and manages the adapter state, validations and interaction with the current connected wallet.

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@aptos-labs/wallet-adapter-core",
+  "version": "0.1.3",
+  "description": "Aptos Wallet Adapter Core",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "license": "Apache-2.0",
+  "exports": {
+    "require": "./dist/index.js",
+    "import": "./dist/index.mjs",
+    "types": "./dist/index.d.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aptos-labs/aptos-wallet-adapter.git"
+  },
+  "homepage": "https://github.com/aptos-labs/aptos-wallet-adapter",
+  "bugs": {
+    "url": "https://github.com/aptos-labs/aptos-wallet-adapter/issues"
+  },
+  "author": "aptoslabs.com",
+  "keywords": [
+    "Aptos",
+    "Aptos Labs",
+    "Wallet",
+    "Wallet Adapter",
+    "Aptos Wallet"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "TIMING=1 eslint \"src/**/*.ts*\"",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "devDependencies": {
+    "@aptos-labs/wallet-adapter-tsconfig": "workspace:*",
+    "eslint": "^8.15.0",
+    "@aptos-labs/eslint-config-adapter": "workspace:*",
+    "tsup": "^5.10.1",
+    "typescript": "^4.5.3"
+  },
+  "dependencies": {
+    "aptos": "^1.3.17",
+    "eventemitter3": "^4.0.7"
+  }
+}

package/src/WalletCore.ts

@@ -0,0 +1,251 @@
+import { Types } from "aptos";
+import { EventEmitter } from "eventemitter3";
+
+import { WalletReadyState } from "./constants";
+import {
+  WalletAccountChangeError,
+  WalletAccountError,
+  WalletConnectionError,
+  WalletDisconnectionError,
+  WalletGetNetworkError,
+  WalletNetworkChangeError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletNotSelectedError,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageError,
+  WalletSignTransactionError,
+} from "./error";
+import {
+  AccountInfo,
+  NetworkInfo,
+  WalletName,
+  SignMessagePayload,
+  SignMessageResponse,
+  Wallet,
+  WalletInfo,
+  WalletCoreEvents,
+} from "./types";
+import {
+  removeLocalStorage,
+  setLocalStorage,
+  scopePollingDetectionStrategy,
+} from "./utils";
+
+export class WalletCore extends EventEmitter<WalletCoreEvents> {
+  private _wallets: Wallet[] = [];
+  private _wallet: Wallet | null = null;
+  private _account: AccountInfo | null = null;
+  private _network: NetworkInfo | null = null;
+
+  private _connecting: boolean = false;
+  private _connected: boolean = false;
+
+  constructor(plugins: Wallet[]) {
+    super();
+    this._wallets = plugins;
+    this.scopePollingDetectionStrategy();
+  }
+
+  private scopePollingDetectionStrategy() {
+    this._wallets?.forEach((wallet: Wallet) => {
+      wallet.readyState =
+        typeof window === "undefined" || typeof document === "undefined"
+          ? WalletReadyState.Unsupported
+          : WalletReadyState.NotDetected;
+      if (typeof window !== "undefined") {
+        scopePollingDetectionStrategy(() => {
+          if (Object.keys(window).includes(wallet.name.toLowerCase())) {
+            wallet.readyState = WalletReadyState.Installed;
+            wallet.provider = window[wallet.name.toLowerCase() as any];
+            this.emit("readyStateChange", wallet);
+            return true;
+          }
+          return false;
+        });
+      }
+    });
+  }
+
+  private isWalletExists(): boolean | WalletNotConnectedError {
+    if (!this._connected || this._connecting || !this._wallet)
+      throw new WalletNotConnectedError().name;
+    if (
+      !(
+        this._wallet.readyState === WalletReadyState.Loadable ||
+        this._wallet.readyState === WalletReadyState.Installed
+      )
+    )
+      throw new WalletNotReadyError().name;
+    return true;
+  }
+
+  private clearData() {
+    this._connected = false;
+    this.setWallet(null);
+    this.setAccount(null);
+    this.setNetwork(null);
+    removeLocalStorage();
+  }
+
+  setWallet(wallet: Wallet | null) {
+    this._wallet = wallet;
+  }
+
+  setAccount(account: AccountInfo | null) {
+    this._account = account;
+  }
+
+  setNetwork(network: NetworkInfo | null) {
+    this._network = network;
+  }
+
+  isConnected(): boolean {
+    return this._connected;
+  }
+
+  get wallets(): Wallet[] {
+    return this._wallets;
+  }
+
+  get wallet(): WalletInfo | null {
+    try {
+      if (!this._wallet) return null;
+      return {
+        name: this._wallet.name,
+        icon: this._wallet.icon,
+        url: this._wallet.url,
+      };
+    } catch (error: any) {
+      throw new WalletNotSelectedError(error).message;
+    }
+  }
+
+  get account(): AccountInfo | null {
+    try {
+      return this._account;
+    } catch (error: any) {
+      throw new WalletAccountError(error).message;
+    }
+  }
+
+  get network(): NetworkInfo | null {
+    try {
+      return this._network;
+    } catch (error: any) {
+      throw new WalletGetNetworkError(error).message;
+    }
+  }
+
+  async connect(walletName: WalletName): Promise<void> {
+    try {
+      const selectedWallet = this._wallets?.find(
+        (wallet: Wallet) => wallet.name === walletName
+      );
+      if (!selectedWallet) return;
+      if (selectedWallet.readyState !== WalletReadyState.Installed) return;
+      if (this._connected) {
+        await this.disconnect();
+      }
+      this._connecting = true;
+      this.setWallet(selectedWallet);
+      const account = await selectedWallet.connect();
+      this.setAccount({ ...account });
+      const network = await selectedWallet.network();
+      this.setNetwork({ ...network });
+      setLocalStorage(selectedWallet.name);
+      this._connected = true;
+      this.emit("connect", account);
+    } catch (error: any) {
+      this.clearData();
+      throw new WalletConnectionError(error).message;
+    } finally {
+      this._connecting = false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    try {
+      this.isWalletExists();
+      await this._wallet?.disconnect();
+      this.clearData();
+      this.emit("disconnect");
+    } catch (error: any) {
+      throw new WalletDisconnectionError(error).message;
+    }
+  }
+
+  async signAndSubmitTransaction(
+    transaction: Types.TransactionPayload
+  ): Promise<any> {
+    try {
+      this.isWalletExists();
+      const response = await this._wallet?.signAndSubmitTransaction(
+        transaction
+      );
+      return response;
+    } catch (error: any) {
+      const errMsg =
+        typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletSignAndSubmitMessageError(errMsg).message;
+    }
+  }
+
+  async signTransaction(
+    transaction: Types.TransactionPayload
+  ): Promise<Uint8Array | null> {
+    try {
+      if (this._wallet && !("signTransaction" in this._wallet)) return null;
+      this.isWalletExists();
+      const response = await (this._wallet as any).signTransaction(transaction);
+      return response;
+    } catch (error: any) {
+      const errMsg =
+        typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletSignTransactionError(errMsg).message;
+    }
+  }
+
+  async signMessage(
+    message: SignMessagePayload
+  ): Promise<SignMessageResponse | null> {
+    try {
+      this.isWalletExists();
+      if (!this._wallet) return null;
+      const response = await this._wallet?.signMessage(message);
+      return response;
+    } catch (error: any) {
+      const errMsg =
+        typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletSignMessageError(errMsg).message;
+    }
+  }
+
+  async onAccountChange(): Promise<void> {
+    try {
+      this.isWalletExists();
+      await this._wallet?.onAccountChange((data: AccountInfo) => {
+        this.setAccount({ ...data });
+        this.emit("accountChange", this._account);
+      });
+    } catch (error: any) {
+      const errMsg =
+        typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletAccountChangeError(errMsg).message;
+    }
+  }
+
+  async onNetworkChange(): Promise<void> {
+    try {
+      this.isWalletExists();
+      await this._wallet?.onNetworkChange((data: NetworkInfo) => {
+        this.setNetwork({ ...data });
+        this.emit("networkChange", this._network);
+      });
+    } catch (error: any) {
+      const errMsg =
+        typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletNetworkChangeError(errMsg).message;
+    }
+  }
+}

package/src/constants.ts

@@ -0,0 +1,25 @@
+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 enum NetworkName {
+  Mainnet = "mainnet",
+  Testnet = "testnet",
+  Devnet = "devnet",
+}

package/src/error/index.ts

@@ -0,0 +1,96 @@
+export class WalletError extends Error {
+  public error: any;
+
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  constructor(message?: string, error?: any) {
+    super(message);
+    this.error = error;
+  }
+}
+
+export class WalletNotSelectedError extends WalletError {
+  name = "WalletNotSelectedError";
+}
+
+export class WalletNotReadyError extends WalletError {
+  name = "WalletNotReadyError";
+}
+
+export class WalletLoadError extends WalletError {
+  name = "WalletLoadError";
+}
+
+export class WalletConfigError extends WalletError {
+  name = "WalletConfigError";
+}
+
+export class WalletConnectionError extends WalletError {
+  name = "WalletConnectionError";
+}
+
+export class WalletDisconnectedError extends WalletError {
+  name = "WalletDisconnectedError";
+}
+
+export class WalletDisconnectionError extends WalletError {
+  name = "WalletDisconnectionError";
+}
+
+export class WalletAccountError extends WalletError {
+  name = "WalletAccountError";
+}
+export class WalletGetNetworkError extends WalletError {
+  name = "WalletGetNetworkError";
+}
+
+export class WalletAccountChangeError extends WalletError {
+  name = "WalletAccountChangeError";
+}
+
+export class WalletNetworkChangeError extends WalletError {
+  name = "WalletNetworkChangeError";
+}
+
+export class WalletPublicKeyError extends WalletError {
+  name = "WalletPublicKeyError";
+}
+
+export class WalletKeypairError extends WalletError {
+  name = "WalletKeypairError";
+}
+
+export class WalletNotConnectedError extends WalletError {
+  name = "WalletNotConnectedError";
+}
+
+export class WalletSendTransactionError extends WalletError {
+  name = "WalletSendTransactionError";
+}
+
+export class WalletSignMessageError extends WalletError {
+  name = "WalletSignMessageError";
+}
+
+export class WalletSignAndSubmitMessageError extends WalletError {
+  name = "WalletSignAndSubmitMessageError";
+}
+
+export class WalletSignTransactionError extends WalletError {
+  name = "WalletSignTransactionError";
+}
+
+export class WalletTimeoutError extends WalletError {
+  name = "WalletTimeoutError";
+}
+
+export class WalletWindowBlockedError extends WalletError {
+  name = "WalletWindowBlockedError";
+}
+
+export class WalletWindowClosedError extends WalletError {
+  name = "WalletWindowClosedError";
+}
+
+export class WalletResponseError extends WalletError {
+  name = "WalletResponseError";
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { WalletCore } from "./WalletCore";
+export * from "./types";
+export * from "./constants";

package/src/types.ts

@@ -0,0 +1,101 @@
+import { Types } from "aptos";
+import { NetworkName, WalletReadyState } from "./constants";
+
+// WalletName is a nominal type that wallet adapters should use, e.g. `'MyCryptoWallet' as WalletName<'MyCryptoWallet'>`
+export type WalletName<T extends string = string> = T & {
+  __brand__: "WalletName";
+};
+export type NetworkInfo = {
+  name: NetworkName | undefined;
+};
+
+export type AccountInfo = {
+  address: string;
+  publicKey: string;
+};
+
+export interface AptosWalletErrorResult {
+  code: number;
+  name: string;
+  message: string;
+}
+
+export interface PluginProvider {
+  connect: () => Promise<AccountInfo>;
+  account: () => Promise<AccountInfo>;
+  disconnect: () => Promise<void>;
+  signAndSubmitTransaction: (
+    transaction: any,
+    options?: any
+  ) => Promise<{ hash: Types.HexEncodedBytes } | AptosWalletErrorResult>;
+  signMessage: (message: SignMessagePayload) => Promise<SignMessageResponse>;
+  network: () => Promise<NetworkName>;
+  onAccountChange: (
+    listener: (newAddress: AccountInfo) => Promise<void>
+  ) => Promise<void>;
+  onNetworkChange: (
+    listener: (network: { networkName: NetworkInfo }) => Promise<void>
+  ) => Promise<void>;
+}
+
+export interface AdapterPluginEvents {
+  onNetworkChange(callback: any): Promise<any>;
+  onAccountChange(callback: any): Promise<any>;
+}
+
+export interface AdapterPluginProps<Name extends string = string> {
+  name: WalletName<Name>;
+  url: string;
+  icon: `data:image/${"svg+xml" | "webp" | "png" | "gif"};base64,${string}`;
+  provider: any;
+  connect(): Promise<any>;
+  disconnect: () => Promise<any>;
+  network: () => Promise<any>;
+  signAndSubmitTransaction<T extends Types.TransactionPayload, V>(
+    transaction: T,
+    options?: V
+  ): Promise<{ hash: Types.HexEncodedBytes }>;
+  signMessage<T extends SignMessagePayload>(
+    message: T
+  ): Promise<SignMessageResponse>;
+}
+
+export type AdapterPlugin<Name extends string = string> =
+  AdapterPluginProps<Name> & AdapterPluginEvents;
+
+export type Wallet<Name extends string = string> = AdapterPlugin<Name> & {
+  readyState?: WalletReadyState;
+};
+
+export type WalletInfo = {
+  name: WalletName;
+  icon: string;
+  url: string;
+};
+
+export declare interface WalletCoreEvents {
+  connect(account: AccountInfo | null): void;
+  disconnect(): void;
+  readyStateChange(wallet: Wallet): void;
+  networkChange(network: NetworkInfo | null): void;
+  accountChange(account: AccountInfo | null): void;
+}
+
+export interface SignMessagePayload {
+  address?: boolean; // Should we include the address of the account in the message
+  application?: boolean; // Should we include the domain of the dapp
+  chainId?: boolean; // Should we include the current chain id the wallet is connected to
+  message: string; // The message to be signed and displayed to the user
+  nonce: string; // A nonce the dapp should generate
+}
+
+export interface SignMessageResponse {
+  address: string;
+  application: string;
+  chainId: number;
+  fullMessage: string; // The message that was generated to sign
+  message: string; // The message passed in by the user
+  nonce: string;
+  prefix: "APTOS"; // Should always be APTOS
+  signature: string; // The signed full message
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export { scopePollingDetectionStrategy } from "./scopePollingDetectionStrategy";
+export * from "./localStorage";

package/src/utils/localStorage.ts

@@ -0,0 +1,15 @@
+import { WalletName } from "../types";
+
+const LOCAL_STORAGE_ITEM_KEY = "AptosWalletName";
+
+export function setLocalStorage(walletName: WalletName) {
+  localStorage.setItem(LOCAL_STORAGE_ITEM_KEY, walletName);
+}
+
+export function removeLocalStorage() {
+  localStorage.removeItem(LOCAL_STORAGE_ITEM_KEY);
+}
+
+export function getLocalStorage() {
+  localStorage.getItem(LOCAL_STORAGE_ITEM_KEY);
+}

package/src/utils/scopePollingDetectionStrategy.ts

@@ -0,0 +1,46 @@
+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/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@aptos-labs/wallet-adapter-tsconfig/base.json",
+  "include": ["."],
+  "exclude": ["dist", "build", "node_modules"],
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["ES2015", "dom", "es2017"]
+  }
+}