@aptos-labs/wallet-adapter-core 3.5.0 → 3.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aptos-labs/wallet-adapter-core",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "description": "Aptos Wallet Adapter Core",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -38,13 +38,14 @@
     "@aptos-labs/wallet-adapter-tsconfig": "0.0.0"
   },
   "dependencies": {
+    "@aptos-labs/wallet-standard": "^0.0.11",
     "buffer": "^6.0.3",
     "eventemitter3": "^4.0.7",
     "tweetnacl": "^1.0.3"
   },
   "peerDependencies": {
-    "aptos": "^1.21.0",
-    "@aptos-labs/ts-sdk": "^1.3.0"
+    "@aptos-labs/ts-sdk": "^1.11.0",
+    "aptos": "^1.21.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/AIP62StandardWallets/WalletStandard.ts

@@ -0,0 +1,176 @@
+import {
+  UserResponse,
+  AptosSignTransactionOutput,
+  AptosSignMessageOutput,
+  AptosSignMessageInput,
+  AptosWallet,
+  UserResponseStatus,
+  AptosSignAndSubmitTransactionOutput,
+  AccountInfo as StandardAccountInfo,
+} from "@aptos-labs/wallet-standard";
+import {
+  AnyRawTransaction,
+  PendingTransactionResponse,
+  Aptos,
+  MultiEd25519Signature,
+  MultiEd25519PublicKey,
+} from "@aptos-labs/ts-sdk";
+
+import { WalletReadyState } from "../constants";
+import {
+  WalletConnectionError,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageAndVerifyError,
+  WalletSignMessageError,
+} from "../error";
+import {
+  AccountInfo,
+  InputTransactionData,
+  Wallet,
+} from "../LegacyWalletPlugins/types";
+import { generalizedErrorMessage } from "../utils";
+
+export type AptosStandardWallet = AptosWallet & {
+  readyState?: WalletReadyState;
+};
+
+export class WalletStandardCore {
+  /**
+   * Signs and submits a transaction to chain
+   *
+   * @param transactionInput InputTransactionData
+   * @returns PendingTransactionResponse
+   */
+  async signAndSubmitTransaction(
+    transactionInput: InputTransactionData,
+    aptos: Aptos,
+    account: AccountInfo,
+    wallet: Wallet
+  ): Promise<PendingTransactionResponse> {
+    try {
+      const transaction = await aptos.transaction.build.simple({
+        sender: account.address.toString(),
+        data: transactionInput.data,
+        options: transactionInput.options,
+      });
+      const response = (await wallet.signAndSubmitTransaction!(
+        transaction
+      )) as UserResponse<AptosSignAndSubmitTransactionOutput>;
+      if (response.status === UserResponseStatus.REJECTED) {
+        throw new WalletConnectionError("User has rejected the request")
+          .message;
+      }
+
+      return response.args;
+    } catch (error: any) {
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignAndSubmitMessageError(errMsg).message;
+    }
+  }
+
+  /**
+   * Signs a transaction
+   *
+   * To support both existing wallet adapter V1 and V2, we support 2 input types
+   *
+   * @param transactionOrPayload AnyRawTransaction
+   * @param options asFeePayer. To sign a transaction as the fee payer sponsor
+   *
+   * @returns AptosSignTransactionOutput
+   */
+  async signTransaction(
+    transaction: AnyRawTransaction,
+    wallet: Wallet,
+    asFeePayer?: boolean
+  ): Promise<AptosSignTransactionOutput> {
+    const response = (await wallet.signTransaction!(
+      transaction,
+      asFeePayer
+    )) as UserResponse<AptosSignTransactionOutput>;
+    if (response.status === UserResponseStatus.REJECTED) {
+      throw new WalletConnectionError("User has rejected the request").message;
+    }
+    return response.args;
+  }
+
+  /**
+   * Sign message
+   *
+   * @param message AptosSignMessageInput
+   * @return AptosSignMessageOutput
+   * @throws WalletSignMessageError
+   */
+  async signMessage(
+    message: AptosSignMessageInput,
+    wallet: Wallet
+  ): Promise<AptosSignMessageOutput> {
+    try {
+      const response = (await wallet.signMessage(
+        message
+      )) as UserResponse<AptosSignMessageOutput>;
+      if (response.status === UserResponseStatus.REJECTED) {
+        throw new WalletConnectionError("User has rejected the request")
+          .message;
+      }
+      return response.args;
+    } catch (error: any) {
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignMessageError(errMsg).message;
+    }
+  }
+
+  /**
+   * Signs a message and verifies the signer
+   * @param message AptosSignMessageInput
+   * @returns boolean
+   */
+  async signMessageAndVerify(
+    message: AptosSignMessageInput,
+    wallet: Wallet
+  ): Promise<boolean> {
+    try {
+      // sign the message
+      const response = (await wallet.signMessage(
+        message
+      )) as UserResponse<AptosSignMessageOutput>;
+      // standard wallet account() method is a required method
+      const account = (await wallet.account!()) as StandardAccountInfo;
+
+      if (response.status === UserResponseStatus.REJECTED) {
+        throw new WalletConnectionError("Failed to sign a message").message;
+      }
+
+      let verified = false;
+      // if is a multi sig wallet with a MultiEd25519Signature type
+      if (response.args.signature instanceof MultiEd25519Signature) {
+        if (!(account.publicKey instanceof MultiEd25519PublicKey)) {
+          throw new WalletSignMessageAndVerifyError(
+            "Public key and Signature type mismatch"
+          ).message;
+        }
+        const { fullMessage, signature } = response.args;
+        const bitmap = signature.bitmap;
+        if (bitmap) {
+          const minKeysRequired = account.publicKey.threshold;
+          if (signature.signatures.length < minKeysRequired) {
+            verified = false;
+          } else {
+            verified = account.publicKey.verifySignature({
+              message: new TextEncoder().encode(fullMessage),
+              signature,
+            });
+          }
+        }
+      } else {
+        verified = account.publicKey.verifySignature({
+          message: new TextEncoder().encode(response.args.fullMessage),
+          signature: response.args.signature,
+        });
+      }
+      return verified;
+    } catch (error: any) {
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignMessageAndVerifyError(errMsg).message;
+    }
+  }
+}

package/src/LegacyWalletPlugins/WalletCoreV1.ts

@@ -0,0 +1,251 @@
+import { HexString, TxnBuilderTypes, Types } from "aptos";
+import EventEmitter from "eventemitter3";
+import { Buffer } from "buffer";
+import {
+  AptosConfig,
+  InputEntryFunctionDataWithRemoteABI,
+  InputGenerateTransactionPayloadData,
+  generateTransactionPayload,
+} from "@aptos-labs/ts-sdk";
+import nacl from "tweetnacl";
+import {
+  WalletNotSupportedMethod,
+  WalletSignAndSubmitMessageError,
+  WalletSignMessageAndVerifyError,
+  WalletSignTransactionError,
+} from "../error";
+import {
+  Wallet,
+  WalletCoreEvents,
+  TransactionOptions,
+  NetworkInfo,
+  InputTransactionData,
+  AccountInfo,
+  SignMessagePayload,
+  SignMessageResponse,
+} from "./types";
+
+import {
+  convertNetwork,
+  convertV2PayloadToV1JSONPayload,
+  convertV2TransactionPayloadToV1BCSPayload,
+} from "./conversion";
+import { areBCSArguments, generalizedErrorMessage } from "../utils";
+
+export class WalletCoreV1 extends EventEmitter<WalletCoreEvents> {
+  /**
+   * Resolve the transaction type (BCS arguments or Simple arguments)
+   *
+   * @param payloadData
+   * @param network
+   * @param wallet
+   * @param transactionInput
+   *
+   * @returns
+   */
+  async resolveSignAndSubmitTransaction(
+    payloadData: InputGenerateTransactionPayloadData,
+    network: NetworkInfo | null,
+    wallet: Wallet,
+    transactionInput: InputTransactionData
+  ) {
+    // first check if each argument is a BCS serialized argument
+    if (areBCSArguments(payloadData.functionArguments)) {
+      const aptosConfig = new AptosConfig({
+        network: convertNetwork(network),
+      });
+      const newPayload = await generateTransactionPayload({
+        ...(payloadData as InputEntryFunctionDataWithRemoteABI),
+        aptosConfig: aptosConfig,
+      });
+      const oldTransactionPayload =
+        convertV2TransactionPayloadToV1BCSPayload(newPayload);
+      // Call and return signAndSubmitBCSTransaction response
+      return await this.signAndSubmitBCSTransaction(
+        oldTransactionPayload,
+        wallet!,
+        {
+          max_gas_amount: transactionInput.options?.maxGasAmount
+            ? BigInt(transactionInput.options?.maxGasAmount)
+            : undefined,
+          gas_unit_price: transactionInput.options?.gasUnitPrice
+            ? BigInt(transactionInput.options?.gasUnitPrice)
+            : undefined,
+        }
+      );
+    }
+
+    // if it is not a bcs serialized arguments transaction, convert to the old
+    // json format
+    const oldTransactionPayload = convertV2PayloadToV1JSONPayload(payloadData);
+    return await this.signAndSubmitTransaction(oldTransactionPayload, wallet!, {
+      max_gas_amount: transactionInput.options?.maxGasAmount
+        ? BigInt(transactionInput.options?.maxGasAmount)
+        : undefined,
+      gas_unit_price: transactionInput.options?.gasUnitPrice
+        ? BigInt(transactionInput.options?.gasUnitPrice)
+        : undefined,
+    });
+  }
+
+  /**
+  Sign and submit an entry (not bcs serialized) transaction type to chain.
+  @param transaction a non-bcs serialized transaction
+  @param options max_gas_amount and gas_unit_limit
+  @return response from the wallet's signAndSubmitTransaction function
+  @throws WalletSignAndSubmitMessageError
+  */
+  async signAndSubmitTransaction(
+    transaction: Types.TransactionPayload,
+    wallet: Wallet,
+    options?: TransactionOptions
+  ): Promise<any> {
+    try {
+      const response = await (wallet as any).signAndSubmitTransaction(
+        transaction,
+        options
+      );
+      return response;
+    } catch (error: any) {
+      const errMsg =
+        typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletSignAndSubmitMessageError(errMsg).message;
+    }
+  }
+
+  /**
+   Sign and submit a bsc serialized transaction type to chain.
+   @param transaction a bcs serialized transaction
+   @param options max_gas_amount and gas_unit_limit
+   @return response from the wallet's signAndSubmitBCSTransaction function
+   @throws WalletSignAndSubmitMessageError
+   */
+  async signAndSubmitBCSTransaction(
+    transaction: TxnBuilderTypes.TransactionPayload,
+    wallet: Wallet,
+    options?: TransactionOptions
+  ): Promise<any> {
+    if (!("signAndSubmitBCSTransaction" in wallet)) {
+      throw new WalletNotSupportedMethod(
+        `Submit a BCS Transaction is not supported by ${wallet.name}`
+      ).message;
+    }
+    try {
+      const response = await (wallet as any).signAndSubmitBCSTransaction(
+        transaction,
+        options
+      );
+      return response;
+    } catch (error: any) {
+      const errMsg =
+        typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletSignAndSubmitMessageError(errMsg).message;
+    }
+  }
+
+  /**
+   Sign transaction
+   @param transaction
+   @param options max_gas_amount and gas_unit_limit
+   @return response from the wallet's signTransaction function
+   @throws WalletSignTransactionError
+   */
+  async signTransaction(
+    transaction: Types.TransactionPayload,
+    wallet: Wallet,
+    options?: TransactionOptions
+  ): Promise<Uint8Array | null> {
+    try {
+      const response = await (wallet as any).signTransaction(
+        transaction,
+        options
+      );
+      return response;
+    } catch (error: any) {
+      const errMsg =
+        typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletSignTransactionError(errMsg).message;
+    }
+  }
+
+  /**
+   * Signs a message and verifies the signer
+   * @param message SignMessagePayload
+   * @returns boolean
+   */
+  async signMessageAndVerify(
+    message: SignMessagePayload,
+    wallet: Wallet,
+    account: AccountInfo
+  ): Promise<boolean> {
+    try {
+      const response = await wallet.signMessage(message);
+      if (!response)
+        throw new WalletSignMessageAndVerifyError("Failed to sign a message")
+          .message;
+      console.log("signMessageAndVerify signMessage response", response);
+
+      // Verify that the bytes were signed using the private key that matches the known public key
+      let verified = false;
+      if (Array.isArray((response as SignMessageResponse).signature)) {
+        // multi sig wallets
+        const { fullMessage, signature, bitmap } =
+          response as SignMessageResponse;
+        if (bitmap) {
+          const minKeysRequired = account.minKeysRequired as number;
+          if ((signature as string[]).length < minKeysRequired) {
+            verified = false;
+          } else {
+            // Getting an array which marks the keys signing the message with 1, while marking 0 for the keys not being used.
+            const bits = Array.from(bitmap).flatMap((n) =>
+              Array.from({ length: 8 }).map((_, i) => (n >> i) & 1)
+            );
+            // Filter out indexes of the keys we need
+            const index = bits.map((_, i) => i).filter((i) => bits[i]);
+
+            const publicKeys = account.publicKey as string[];
+            const matchedPublicKeys = publicKeys.filter(
+              (_: string, i: number) => index.includes(i)
+            );
+
+            verified = true;
+            for (let i = 0; i < (signature as string[]).length; i++) {
+              const isSigVerified = nacl.sign.detached.verify(
+                Buffer.from(fullMessage),
+                Buffer.from((signature as string[])[i], "hex"),
+                Buffer.from(matchedPublicKeys[i], "hex")
+              ); // `isSigVerified` should be `true` for every signature
+
+              if (!isSigVerified) {
+                verified = false;
+                break;
+              }
+            }
+          }
+        } else {
+          throw new WalletSignMessageAndVerifyError("Failed to get a bitmap")
+            .message;
+        }
+      } else {
+        // single sig wallets
+        // support for when address doesnt have hex prefix (0x)
+        const currentAccountPublicKey = new HexString(
+          account.publicKey as string
+        );
+        // support for when address doesnt have hex prefix (0x)
+        const signature = new HexString(
+          (response as SignMessageResponse).signature as string
+        );
+        verified = nacl.sign.detached.verify(
+          Buffer.from((response as SignMessageResponse).fullMessage),
+          Buffer.from(signature.noPrefix(), "hex"),
+          Buffer.from(currentAccountPublicKey.noPrefix(), "hex")
+        );
+      }
+      return verified;
+    } catch (error: any) {
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignMessageAndVerifyError(errMsg).message;
+    }
+  }
+}

package/src/{conversion.ts → LegacyWalletPlugins/conversion.ts}

@@ -4,11 +4,14 @@ import {
   InputGenerateTransactionPayloadData,
   TypeTag,
 } from "@aptos-labs/ts-sdk";
+import { NetworkInfo as StandardNetworkInfo } from "@aptos-labs/wallet-standard";
 import { BCS, TxnBuilderTypes, Types } from "aptos";
 import { NetworkInfo } from "./types";
 
 // old => new
-export function convertNetwork(networkInfo: NetworkInfo | null): Network {
+export function convertNetwork(
+  networkInfo: NetworkInfo | StandardNetworkInfo | null
+): Network {
   switch (networkInfo?.name.toLowerCase()) {
     case "mainnet" as Network:
       return Network.MAINNET;

package/src/{types.ts → LegacyWalletPlugins/types.ts}

@@ -1,14 +1,22 @@
 import { Types } from "aptos";
 import {
   Network,
-  InputGenerateTransactionData,
   InputGenerateTransactionOptions,
   InputSubmitTransactionData,
   PendingTransactionResponse,
   AccountAddressInput,
   InputGenerateTransactionPayloadData,
+  AnyRawTransaction,
+  Signature,
 } from "@aptos-labs/ts-sdk";
-import { WalletReadyState } from "./constants";
+import { WalletReadyState } from "../constants";
+import {
+  AptosSignAndSubmitTransactionOutput,
+  AptosSignMessageOutput,
+  UserResponse,
+  AccountInfo as StandardAccountInfo,
+  NetworkInfo as StandardNetworkInfo,
+} from "@aptos-labs/wallet-standard";
 
 export { TxnBuilderTypes, Types } from "aptos";
 export type {
@@ -54,6 +62,7 @@ export declare interface WalletCoreEvents {
   connect(account: AccountInfo | null): void;
   disconnect(): void;
   readyStateChange(wallet: Wallet): void;
+  standardWalletsAdded(wallets: Wallet): void;
   networkChange(network: NetworkInfo | null): void;
   accountChange(account: AccountInfo | null): void;
 }
@@ -74,16 +83,16 @@ export interface SignMessageResponse {
   message: string; // The message passed in by the user
   nonce: string;
   prefix: "APTOS"; // Should always be APTOS
-  signature: string | string[]; // The signed full message
+  signature: string | string[] | Signature; // The signed full message
   bitmap?: Uint8Array; // a 4-byte (32 bits) bit-vector of length N
 }
 
 export type OnNetworkChange = (
-  callBack: (networkInfo: NetworkInfo) => Promise<void>
+  callBack: (networkInfo: NetworkInfo | StandardNetworkInfo) => Promise<void>
 ) => Promise<void>;
 
 export type OnAccountChange = (
-  callBack: (accountInfo: AccountInfo) => Promise<any>
+  callBack: (accountInfo: AccountInfo | StandardAccountInfo) => Promise<any>
 ) => Promise<void>;
 
 export interface AdapterPluginEvents {
@@ -96,25 +105,37 @@ export interface AdapterPluginProps<Name extends string = string> {
   name: WalletName<Name>;
   url: string;
   icon: `data:image/${"svg+xml" | "webp" | "png" | "gif"};base64,${string}`;
-  version?: "v1" | "v2";
   providerName?: string;
   provider: any;
+  // Compatible with legacy wallet plugin
   deeplinkProvider?: (data: { url: string }) => string;
+  // Comaptible with AIP-62 standard wallet
+  openInMobileApp?: () => void;
   connect(): Promise<any>;
   disconnect: () => Promise<any>;
   network: () => Promise<any>;
-  signAndSubmitTransaction(
-    transaction: Types.TransactionPayload | InputGenerateTransactionData,
+  signAndSubmitTransaction?(
+    transaction:
+      | Types.TransactionPayload
+      | InputTransactionData
+      | AnyRawTransaction,
     options?: InputGenerateTransactionOptions
   ): Promise<
-    { hash: Types.HexEncodedBytes; output?: any } | PendingTransactionResponse
+    | { hash: Types.HexEncodedBytes; output?: any }
+    | PendingTransactionResponse
+    | UserResponse<AptosSignAndSubmitTransactionOutput>
   >;
   submitTransaction?(
     transaction: InputSubmitTransactionData
   ): Promise<PendingTransactionResponse>;
   signMessage<T extends SignMessagePayload>(
     message: T
-  ): Promise<SignMessageResponse>;
+  ): Promise<SignMessageResponse | UserResponse<AptosSignMessageOutput>>;
+  signTransaction?( // `any` type for backwards compatibility, especially for identity connect
+    transactionOrPayload: any,
+    optionsOrAsFeePayer?: any
+  ): Promise<any>;
+  account?: () => Promise<AccountInfo | StandardAccountInfo>;
 }
 
 export type AdapterPlugin<Name extends string = string> =
@@ -122,6 +143,7 @@ export type AdapterPlugin<Name extends string = string> =
 
 export type Wallet<Name extends string = string> = AdapterPlugin<Name> & {
   readyState?: WalletReadyState;
+  isAIP62Standard?: boolean;
 };
 
 export interface TransactionOptions {