@aptos-labs/wallet-adapter-core 2.5.1 → 3.0.0

package/src/WalletCore.ts

@@ -1,4 +1,18 @@
-import { HexString, TxnBuilderTypes, Types } from "aptos";
+import { HexString, TxnBuilderTypes, Types, BCS } from "aptos";
+import {
+  InputGenerateTransactionData,
+  AnyRawTransaction,
+  AccountAuthenticator,
+  AccountAuthenticatorEd25519,
+  Ed25519PublicKey,
+  InputGenerateTransactionOptions,
+  Ed25519Signature,
+  AptosConfig,
+  generateTransactionPayload,
+  InputSubmitTransactionData,
+  PendingTransactionResponse,
+  InputEntryFunctionDataWithRemoteABI,
+} from "@aptos-labs/ts-sdk";
 import EventEmitter from "eventemitter3";
 import nacl from "tweetnacl";
 import { Buffer } from "buffer";
@@ -23,27 +37,33 @@ import {
 import {
   AccountInfo,
   NetworkInfo,
-  WalletName,
   SignMessagePayload,
-  SignMessageResponse,
   Wallet,
   WalletInfo,
   WalletCoreEvents,
-  TransactionOptions,
+  SignMessageResponse,
 } from "./types";
 import {
   removeLocalStorage,
   setLocalStorage,
   scopePollingDetectionStrategy,
   isRedirectable,
+  generalizedErrorMessage,
 } from "./utils";
 import { getNameByAddress } from "./ans";
+import {
+  convertNetwork,
+  convertV2TransactionPayloadToV1BCSPayload,
+  convertV2PayloadToV1JSONPayload,
+} from "./conversion";
+import { WalletCoreV1 } from "./WalletCoreV1";
 
 export class WalletCore extends EventEmitter<WalletCoreEvents> {
   private _wallets: ReadonlyArray<Wallet> = [];
   private _wallet: Wallet | null = null;
   private _account: AccountInfo | null = null;
   private _network: NetworkInfo | null = null;
+  private readonly waletCoreV1: WalletCoreV1 = new WalletCoreV1();
 
   private _connecting: boolean = false;
   private _connected: boolean = false;
@@ -177,7 +197,7 @@ export class WalletCore extends EventEmitter<WalletCoreEvents> {
    * If all good, we connect the wallet by calling `this.connectWallet`
    * @param walletName. The wallet name we want to connect.
    */
-  async connect(walletName: WalletName): Promise<void | string> {
+  async connect(walletName: string): Promise<void | string> {
     const selectedWallet = this._wallets?.find(
       (wallet: Wallet) => wallet.name === walletName
     );
@@ -236,16 +256,16 @@ export class WalletCore extends EventEmitter<WalletCoreEvents> {
       this.emit("connect", account);
     } catch (error: any) {
       this.clearData();
-      const errMsg =
-        typeof error == "object" && "message" in error ? error.message : error;
+
+      const errMsg = generalizedErrorMessage(error);
       throw new WalletConnectionError(errMsg).message;
     } finally {
       this._connecting = false;
     }
   }
 
-  /** 
-  Disconnect the exisitng wallet. On success, we clear the 
+  /**
+  Disconnect the exisitng wallet. On success, we clear the
   current account, current network and LocalStorage data.
   @emit emits "disconnect" event
   @throws WalletDisconnectionError
@@ -257,121 +277,207 @@ export class WalletCore extends EventEmitter<WalletCoreEvents> {
       this.clearData();
       this.emit("disconnect");
     } catch (error: any) {
-      const errMsg =
-        typeof error == "object" && "message" in error ? error.message : error;
+      const errMsg = generalizedErrorMessage(error);
       throw new WalletDisconnectionError(errMsg).message;
     }
   }
 
-  /** 
-  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
-  */
+  /**
+   * Signs and submits a transaction to chain
+   *
+   * @param transactionInput InputGenerateTransactionData
+   * @param options optional. A configuration object to generate a transaction by
+   * @returns The pending transaction hash (V1 output) | PendingTransactionResponse (V2 output)
+   */
   async signAndSubmitTransaction(
-    transaction: Types.TransactionPayload,
-    options?: TransactionOptions
-  ): Promise<any> {
+    transactionInput: InputGenerateTransactionData,
+    options?: InputGenerateTransactionOptions
+  ): Promise<
+    { hash: Types.HexEncodedBytes; output?: any } | PendingTransactionResponse
+  > {
     try {
       this.doesWalletExist();
-      const response = await this._wallet?.signAndSubmitTransaction(
-        transaction,
-        options
+
+      // wallet supports sdk v2
+      if (this._wallet?.version === "v2") {
+        const response = await this._wallet.signAndSubmitTransaction(
+          transactionInput,
+          options
+        );
+        // response should be PendingTransactionResponse
+        return response;
+      }
+
+      // get the payload piece from the input
+      const payloadData = transactionInput.data;
+
+      // if first function arguments is an object (i.e a bcs serialized argument)
+      // we assume the transaction should be a bcs serialized transaction
+      if (typeof payloadData.functionArguments[0] === "object") {
+        const aptosConfig = new AptosConfig({
+          network: convertNetwork(this._network),
+        });
+        const newPayload = await generateTransactionPayload({
+          ...(payloadData as InputEntryFunctionDataWithRemoteABI),
+          aptosConfig: aptosConfig,
+        });
+        const oldTransactionPayload =
+          convertV2TransactionPayloadToV1BCSPayload(newPayload);
+        const response = await this.waletCoreV1.signAndSubmitBCSTransaction(
+          oldTransactionPayload,
+          this._wallet!,
+          {
+            max_gas_amount: options?.maxGasAmount
+              ? BigInt(options?.maxGasAmount)
+              : undefined,
+            gas_unit_price: options?.gasUnitPrice
+              ? BigInt(options?.gasUnitPrice)
+              : undefined,
+          }
+        );
+        const { hash, ...output } = response;
+        return { hash, output };
+      }
+
+      // if it is not a bcs serialized arguments transaction, convert to the old
+      // json format
+      const oldTransactionPayload =
+        convertV2PayloadToV1JSONPayload(payloadData);
+      const response = await this.waletCoreV1.signAndSubmitTransaction(
+        oldTransactionPayload,
+        this._wallet!,
+        {
+          max_gas_amount: options?.maxGasAmount
+            ? BigInt(options?.maxGasAmount)
+            : undefined,
+          gas_unit_price: options?.gasUnitPrice
+            ? BigInt(options?.gasUnitPrice)
+            : undefined,
+        }
       );
-      return response;
+      const { hash, ...output } = response;
+      return { hash, output };
     } catch (error: any) {
-      const errMsg =
-        typeof error == "object" && "message" in error ? error.message : error;
+      const errMsg = generalizedErrorMessage(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,
-    options?: TransactionOptions
-  ): Promise<any> {
-    if (this._wallet && !("signAndSubmitBCSTransaction" in this._wallet)) {
-      throw new WalletNotSupportedMethod(
-        `Submit a BCS Transaction is not supported by ${this.wallet?.name}`
-      ).message;
-    }
-
+  /**
+   * Signs a transaction
+   *
+   * To support both existing wallet adapter V1 and V2, we support 2 input types
+   *
+   * @param transactionOrPayload AnyRawTransaction - V2 input | Types.TransactionPayload - V1 input
+   * @param options optional. V1 input
+   *
+   * @returns AccountAuthenticator
+   */
+  async signTransaction(
+    transactionOrPayload: AnyRawTransaction | Types.TransactionPayload,
+    asFeePayer?: boolean,
+    options?: InputGenerateTransactionOptions
+  ): Promise<AccountAuthenticator> {
     try {
       this.doesWalletExist();
-      const response = await (this._wallet as any).signAndSubmitBCSTransaction(
-        transaction,
-        options
+      // if input is AnyRawTransaction, i.e V2
+      if ("rawTransaction" in transactionOrPayload) {
+        if (this._wallet?.version !== "v2") {
+          throw new WalletNotSupportedMethod(
+            `Sign Transaction V2 is not supported by ${this.wallet?.name}`
+          ).message;
+        }
+        const accountAuthenticator = (this._wallet as any).signTransaction(
+          transactionOrPayload,
+          asFeePayer
+        );
+
+        return accountAuthenticator;
+      }
+
+      // check current signTransaction function exists
+      if (this._wallet && !("signTransaction" in this._wallet)) {
+        throw new WalletNotSupportedMethod(
+          `Sign Transaction is not supported by ${this.wallet?.name}`
+        ).message;
+      }
+
+      const response = await this.waletCoreV1.signTransaction(
+        transactionOrPayload as Types.TransactionPayload,
+        this._wallet!,
+        {
+          max_gas_amount: options?.maxGasAmount
+            ? BigInt(options?.maxGasAmount)
+            : undefined,
+          gas_unit_price: options?.gasUnitPrice
+            ? BigInt(options?.gasUnitPrice)
+            : undefined,
+        }
       );
-      return response;
+      if (!response) {
+        throw new Error("error");
+      }
+
+      // Convert retuned bcs serialized SignedTransaction into V2 AccountAuthenticator
+      const deserializer1 = new BCS.Deserializer(response);
+      const deserializedSignature =
+        TxnBuilderTypes.SignedTransaction.deserialize(deserializer1);
+      const transactionAuthenticator =
+        deserializedSignature.authenticator as TxnBuilderTypes.TransactionAuthenticatorEd25519;
+
+      const publicKey = transactionAuthenticator.public_key.value;
+      const signature = transactionAuthenticator.signature.value;
+
+      const accountAuthenticator = new AccountAuthenticatorEd25519(
+        new Ed25519PublicKey(publicKey),
+        new Ed25519Signature(signature)
+      );
+      return accountAuthenticator;
     } catch (error: any) {
-      const errMsg =
-        typeof error == "object" && "message" in error ? error.message : error;
-      throw new WalletSignAndSubmitMessageError(errMsg).message;
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignTransactionError(errMsg).message;
     }
   }
 
-  /** 
-  Sign transaction (doesnt submit to chain).
-  @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,
-    options?: TransactionOptions
-  ): Promise<Uint8Array | null> {
-    if (this._wallet && !("signTransaction" in this._wallet)) {
-      throw new WalletNotSupportedMethod(
-        `Sign Transaction is not supported by ${this.wallet?.name}`
-      ).message;
-    }
-
+  /**
+   Sign message (doesnt submit to chain).
+   @param message
+   @return response from the wallet's signMessage function
+   @throws WalletSignMessageError
+   */
+  async signMessage(message: SignMessagePayload): Promise<SignMessageResponse> {
     try {
       this.doesWalletExist();
-      const response = await (this._wallet as any).signTransaction(
-        transaction,
-        options
-      );
+      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 WalletSignTransactionError(errMsg).message;
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignMessageError(errMsg).message;
     }
   }
 
-  /** 
-  Sign message (doesnt submit to chain).
-  @param message
-  @return response from the wallet's signMessage function
-  @throws WalletSignMessageError
-  */
-  async signMessage(
-    message: SignMessagePayload
-  ): Promise<SignMessageResponse | null> {
+  async submitTransaction(
+    transaction: InputSubmitTransactionData
+  ): Promise<PendingTransactionResponse> {
+    if (this._wallet && !("submitTransaction" in this._wallet)) {
+      throw new WalletNotSupportedMethod(
+        `Submit Transaction is not supported by ${this.wallet?.name}`
+      ).message;
+    }
     try {
       this.doesWalletExist();
-      if (!this._wallet) return null;
-      const response = await this._wallet?.signMessage(message);
-      return response;
+      const pendingTransaction = (this._wallet as any).submitTransaction(
+        transaction
+      );
+
+      return pendingTransaction;
     } catch (error: any) {
-      const errMsg =
-        typeof error == "object" && "message" in error ? error.message : error;
-      throw new WalletSignMessageError(errMsg).message;
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignTransactionError(errMsg).message;
     }
   }
 
-  /** 
+  /**
   Event for when account has changed on the wallet
   @return the new account info
   @throws WalletAccountChangeError
@@ -385,13 +491,12 @@ export class WalletCore extends EventEmitter<WalletCoreEvents> {
         this.emit("accountChange", this._account);
       });
     } catch (error: any) {
-      const errMsg =
-        typeof error == "object" && "message" in error ? error.message : error;
+      const errMsg = generalizedErrorMessage(error);
       throw new WalletAccountChangeError(errMsg).message;
     }
   }
 
-  /** 
+  /**
   Event for when network has changed on the wallet
   @return the new network info
   @throws WalletNetworkChangeError
@@ -405,12 +510,16 @@ export class WalletCore extends EventEmitter<WalletCoreEvents> {
         this.emit("networkChange", this._network);
       });
     } catch (error: any) {
-      const errMsg =
-        typeof error == "object" && "message" in error ? error.message : error;
+      const errMsg = generalizedErrorMessage(error);
       throw new WalletNetworkChangeError(errMsg).message;
     }
   }
 
+  /**
+   * Signs a message and verifies the signer
+   * @param message SignMessagePayload
+   * @returns boolean
+   */
   async signMessageAndVerify(message: SignMessagePayload): Promise<boolean> {
     try {
       this.doesWalletExist();
@@ -475,8 +584,7 @@ export class WalletCore extends EventEmitter<WalletCoreEvents> {
       }
       return verified;
     } catch (error: any) {
-      const errMsg =
-        typeof error == "object" && "message" in error ? error.message : error;
+      const errMsg = generalizedErrorMessage(error);
       throw new WalletSignMessageAndVerifyError(errMsg).message;
     }
   }

package/src/WalletCoreV1.ts

@@ -0,0 +1,85 @@
+import { TxnBuilderTypes, Types } from "aptos";
+import EventEmitter from "eventemitter3";
+
+import {
+  WalletSignAndSubmitMessageError,
+  WalletSignTransactionError,
+} from "./error";
+import { Wallet, WalletCoreEvents, TransactionOptions } from "./types";
+
+export class WalletCoreV1 extends EventEmitter<WalletCoreEvents> {
+  /**
+  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> {
+    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 (doesnt submit to chain).
+   @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;
+    }
+  }
+}

package/src/conversion.ts

@@ -0,0 +1,57 @@
+import {
+  Network,
+  TransactionPayload,
+  InputGenerateTransactionPayloadData,
+  TypeTag,
+} from "@aptos-labs/ts-sdk";
+import { BCS, TxnBuilderTypes, Types } from "aptos";
+import { NetworkInfo } from "./types";
+
+// old => new
+export function convertNetwork(networkInfo: NetworkInfo | null): Network {
+  switch (networkInfo?.name.toLowerCase()) {
+    case "mainnet" as Network:
+      return Network.MAINNET;
+    case "testnet" as Network:
+      return Network.TESTNET;
+    case "devnet" as Network:
+      return Network.DEVNET;
+    default:
+      throw new Error("Invalid network name");
+  }
+}
+
+// new => old
+export function convertV2TransactionPayloadToV1BCSPayload(
+  payload: TransactionPayload
+): TxnBuilderTypes.TransactionPayload {
+  const deserializer = new BCS.Deserializer(payload.bcsToBytes());
+  return TxnBuilderTypes.TransactionPayload.deserialize(deserializer);
+}
+
+export function convertV2PayloadToV1JSONPayload(
+  payload: InputGenerateTransactionPayloadData
+): Types.TransactionPayload {
+  if ("bytecode" in payload) {
+    // is a script payload
+    throw new Error("script payload not supported");
+  } else {
+    // is entry function payload
+    const stringTypeTags: string[] | undefined = payload.typeArguments?.map(
+      (typeTag) => {
+        if (typeTag instanceof TypeTag) {
+          return typeTag.toString();
+        }
+        return typeTag;
+      }
+    );
+    const newPayload: Types.TransactionPayload = {
+      type: "entry_function_payload",
+      function: payload.function,
+      type_arguments: stringTypeTags || [],
+      arguments: payload.functionArguments,
+    };
+
+    return newPayload;
+  }
+}