@aptos-labs/ts-sdk 1.13.3-zeta.3 → 1.14.0-zeta.0

package/src/account/MultiKeyAccount.ts

@@ -2,13 +2,26 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { Account } from "./Account";
-import { MultiKey, MultiSignature, PublicKey, Signature } from "../core/crypto";
+import { MultiKey, MultiKeySignature, PublicKey } from "../core/crypto";
 import { AccountAddress } from "../core/accountAddress";
 import { HexInput, SigningScheme } from "../types";
 import { AccountAuthenticatorMultiKey } from "../transactions/authenticator/account";
 import { AnyRawTransaction } from "../transactions/types";
 import { KeylessAccount } from "./KeylessAccount";
 
+export interface VerifyMultiKeySignatureArgs {
+  message: HexInput;
+  signature: MultiKeySignature;
+}
+
+/**
+ * Signer implementation for the MultiKey authentication scheme.
+ *
+ * This accounts to use a M of N signing scheme. M and N are specified in the {@link MultiKey}
+ * It signs messages via the array of M number of Accounts that individually correspond to a public key in the {@link MultiKey}.
+ *
+ * Note: Generating a signer instance does not create the account on-chain.
+ */
 export class MultiKeyAccount implements Account {
   /**
    * Public key associated with the account
@@ -25,39 +38,60 @@ export class MultiKeyAccount implements Account {
    */
   readonly signingScheme: SigningScheme;
 
-  signers: Account[];
+  /**
+   * The signers used to sign messages.  These signers should correspond to public keys in the
+   * MultiKeyAccount's public key.  The number of signers should be equal or greater
+   * than this.publicKey.signaturesRequired
+   */
+  readonly signers: Account[];
+
+  /**
+   * An array of indicies where for signer[i], signerIndicies[i] is the index of the corresponding public key in
+   * publicKey.publicKeys.  Used to derive the right public key to use for verification.
+   */
+  readonly signerIndicies: number[];
 
-  signaturesBitmap: Uint8Array;
+  readonly signaturesBitmap: Uint8Array;
 
   /**
-   * constructor for Account
-   *
-   * Need to update this to use the new crypto library if new schemes are added.
-   *
-   * @param args.privateKey PrivateKey - private key of the account
-   * @param args.address AccountAddress - address of the account
-   * @param args.legacy optional. If set to false, the keypair authentication keys will be derived with a unified scheme.
-   * Defaults to deriving an authentication key with the legacy scheme.
+   * constructor for MultiKeyAccount
    *
-   * This method is private because it should only be called by the factory static methods.
-   * @returns Account
+   * @param args.multiKey the multikey of the account which consists of N public keys and a number M which is
+   * the number of required signatures.
+   * @param args.signers an array of M signers that will be used to sign the transaction
+   * @returns MultiKeyAccount
    */
   constructor(args: { multiKey: MultiKey; signers: Account[] }) {
     const { multiKey, signers } = args;
 
     this.publicKey = multiKey;
-    this.signers = signers;
     this.signingScheme = SigningScheme.MultiKey;
 
     this.accountAddress = this.publicKey.authKey().derivedAddress();
 
-    const bits: number[] = [];
+    // Get the index of each respective signer in the bitmap
+    const bitPositions: number[] = [];
     for (const signer of signers) {
-      bits.push(this.publicKey.getIndex(signer.publicKey));
+      bitPositions.push(this.publicKey.getIndex(signer.publicKey));
     }
-    this.signaturesBitmap = this.publicKey.createBitmap({ bits });
+    // Zip signers and bit positions and sort signers by bit positions in order
+    // to ensure the signature is signed in ascending order according to the bitmap.
+    // Authentication on chain will fail otherwise.
+    const signersAndBitPosition: [Account, number][] = signers.map((signer, index) => [signer, bitPositions[index]]);
+    signersAndBitPosition.sort((a, b) => a[1] - b[1]);
+    this.signers = signersAndBitPosition.map((value) => value[0]);
+    this.signerIndicies = signersAndBitPosition.map((value) => value[1]);
+    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });
   }
 
+  /**
+   * Static constructor for MultiKeyAccount
+   *
+   * @param args.publicKeys the N public keys of the MultiKeyAccount
+   * @param args.signaturesRequired the number of signatures required
+   * @param args.signers an array of M signers that will be used to sign the transaction
+   * @returns MultiKeyAccount
+   */
   static fromPublicKeysAndSigners(args: {
     publicKeys: PublicKey[];
     signaturesRequired: number;
@@ -72,7 +106,21 @@ export class MultiKeyAccount implements Account {
     return account instanceof MultiKeyAccount;
   }
 
-  signWithAuthenticator(transaction: AnyRawTransaction) {
+  /**
+   * Sign a message using the account's signers.
+   * @param message the signing message, as binary input
+   * @return the AccountAuthenticator containing the signature, together with the account's public key
+   */
+  signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiKey {
+    return new AccountAuthenticatorMultiKey(this.publicKey, this.sign(message));
+  }
+
+  /**
+   * Sign a transaction using the account's signers.
+   * @param transaction the raw transaction
+   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+   */
+  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey {
     return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));
   }
 
@@ -82,38 +130,53 @@ export class MultiKeyAccount implements Account {
   }
 
   /**
-   * Sign the given message with the private key.
-   *
-   * TODO: Add sign transaction or specific types
-   *
-   * @param data in HexInput format
-   * @returns Signature
+   * Sign the given message using the MultiKeyAccount's signers
+   * @param message in HexInput format
+   * @returns MultiKeySignature
    */
-  sign(data: HexInput): MultiSignature {
+  sign(data: HexInput): MultiKeySignature {
     const signatures = [];
     for (const signer of this.signers) {
       signatures.push(signer.sign(data));
     }
-    return new MultiSignature({ signatures, bitmap: this.signaturesBitmap });
+    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });
   }
 
-  signTransaction(transaction: AnyRawTransaction) {
+  /**
+   * Sign the given transaction using the MultiKeyAccount's signers
+   * @param transaction the transaction to be signed
+   * @returns MultiKeySignature
+   */
+  signTransaction(transaction: AnyRawTransaction): MultiKeySignature {
     const signatures = [];
     for (const signer of this.signers) {
       signatures.push(signer.signTransaction(transaction));
     }
-    return new MultiSignature({ signatures, bitmap: this.signaturesBitmap });
+    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });
   }
 
   /**
    * Verify the given message and signature with the public key.
    *
    * @param args.message raw message data in HexInput format
-   * @param args.signature signed message Signature
-   * @returns
+   * @param args.signatures signed message MultiKeySignature
+   * @returns boolean
    */
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args: { message: HexInput; signature: Signature }): boolean {
+  verifySignature(args: VerifyMultiKeySignatureArgs): boolean {
+    const { message, signature } = args;
+    const isSignerIndiciesSorted = this.signerIndicies.every(
+      (value, i) => i === 0 || value >= this.signerIndicies[i - 1],
+    );
+    if (!isSignerIndiciesSorted) {
+      return false;
+    }
+    for (let i = 0; i < signature.signatures.length; i += 1) {
+      const singleSignature = signature.signatures[i];
+      const publicKey = this.publicKey.publicKeys[this.signerIndicies[i]];
+      if (!publicKey.verifySignature({ message, signature: singleSignature })) {
+        return false;
+      }
+    }
     return true;
   }
 }

package/src/account/SingleKeyAccount.ts

@@ -104,20 +104,50 @@ export class SingleKeyAccount implements Account {
 
   // region Account
 
+  /**
+   * Verify the given message and signature with the public key.
+   *
+   * @param args.message raw message data in HexInput format
+   * @param args.signature signed message Signature
+   * @returns
+   */
   verifySignature(args: VerifySingleKeySignatureArgs): boolean {
     return this.publicKey.verifySignature(args);
   }
 
-  signWithAuthenticator(transaction: AnyRawTransaction) {
-    const signature = this.sign(generateSigningMessageForTransaction(transaction));
-    return new AccountAuthenticatorSingleKey(this.publicKey, signature);
+  /**
+   * Sign a message using the account's private key.
+   * @param message the signing message, as binary input
+   * @return the AccountAuthenticator containing the signature, together with the account's public key
+   */
+  signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey {
+    return new AccountAuthenticatorSingleKey(this.publicKey, this.sign(message));
   }
 
-  sign(message: HexInput) {
+  /**
+   * Sign a transaction using the account's private key.
+   * @param transaction the raw transaction
+   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+   */
+  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey {
+    return new AccountAuthenticatorSingleKey(this.publicKey, this.signTransaction(transaction));
+  }
+
+  /**
+   * Sign the given message using the account's private key.
+   * @param message in HexInput format
+   * @returns Signature
+   */
+  sign(message: HexInput): AnySignature {
     return new AnySignature(this.privateKey.sign(message));
   }
 
-  signTransaction(transaction: AnyRawTransaction) {
+  /**
+   * Sign the given transaction using the account's private key.
+   * @param transaction the transaction to be signed
+   * @returns Signature
+   */
+  signTransaction(transaction: AnyRawTransaction): AnySignature {
     return this.sign(generateSigningMessageForTransaction(transaction));
   }
 

package/src/account/index.ts

@@ -1,6 +1,6 @@
 export * from "./Ed25519Account";
 export * from "./Account";
 export * from "./SingleKeyAccount";
-export * from "./KeylessAccount";
 export * from "./EphemeralKeyPair";
+export * from "./KeylessAccount";
 export * from "./MultiKeyAccount";

package/src/cli/index.ts

@@ -1 +1,2 @@
 export * from "./localNode";
+export * from "./move";

package/src/cli/move.ts

@@ -0,0 +1,183 @@
+import { spawn } from "child_process";
+import { AccountAddress } from "../core";
+import { Network } from "../utils";
+
+export class Move {
+  /**
+   * Function to initialize current directory for Aptos
+   *
+   * Configuration will be pushed into .aptos/config.yaml
+   * @param args.network optional Netowrk type argument to use for default settings, default is local
+   * @param args.profile optional Profile to use from the config file, default is 'default'
+   * This will be used to override associated settings such as the REST URL, the Faucet URL, and the private key arguments.
+   *
+   * @returns
+   */
+  async init(args: { network?: Network; profile?: string }): Promise<boolean> {
+    const { network, profile } = args;
+    const cliArgs = ["aptos", "init", `--network=${network ?? "local"}`, `--profile=${profile ?? "default"}`];
+
+    return this.runCommand(cliArgs);
+  }
+
+  /**
+   * Function to compile a package
+   *
+   * @param args.packageDirectoryPath Path to a move package (the folder with a Move.toml file)
+   * @param args.namedAddresses  Named addresses for the move binary
+   * @example
+   * {
+   *  alice:0x1234, bob:0x5678
+   * }
+   *
+   * @returns
+   */
+  async compile(args: {
+    packageDirectoryPath: string;
+    namedAddresses: Record<string, AccountAddress>;
+  }): Promise<boolean> {
+    const { packageDirectoryPath, namedAddresses } = args;
+    const cliArgs = ["aptos", "move", "compile", "--package-dir", packageDirectoryPath, "--skip-fetch-latest-git-deps"];
+
+    const addressesMap = this.parseNamedAddresses(namedAddresses);
+
+    cliArgs.push(...this.prepareNamedAddresses(addressesMap));
+
+    return this.runCommand(cliArgs);
+  }
+
+  /**
+   * Function to run Move unit tests for a package
+   *
+   * @param args.packageDirectoryPath Path to a move package (the folder with a Move.toml file)
+   * @param args.namedAddresses  Named addresses for the move binary
+   * @example
+   * {
+   *  alice:0x1234, bob:0x5678
+   * }
+   *
+   * @returns
+   */
+  async test(args: { packageDirectoryPath: string; namedAddresses: Record<string, AccountAddress> }): Promise<boolean> {
+    const { packageDirectoryPath, namedAddresses } = args;
+    const cliArgs = ["aptos", "move", "test", "--package-dir", packageDirectoryPath, "--skip-fetch-latest-git-deps"];
+
+    const addressesMap = this.parseNamedAddresses(namedAddresses);
+
+    cliArgs.push(...this.prepareNamedAddresses(addressesMap));
+
+    return this.runCommand(cliArgs);
+  }
+
+  /**
+   * Function to publishe the modules in a Move package to the Aptos blockchain
+   *
+   * @param args.packageDirectoryPath Path to a move package (the folder with a Move.toml file)
+   * @param args.namedAddresses  Named addresses for the move binary
+   * @example
+   * {
+   *  alice:0x1234, bob:0x5678
+   * }
+   * @param args.profile optional Profile to use from the config file.
+   *
+   * @returns
+   */
+  async publish(args: {
+    packageDirectoryPath: string;
+    namedAddresses: Record<string, AccountAddress>;
+    profile?: string;
+  }): Promise<boolean> {
+    const { packageDirectoryPath, namedAddresses, profile } = args;
+    const cliArgs = [
+      "aptos",
+      "move",
+      "publish",
+      "--package-dir",
+      packageDirectoryPath,
+      "--skip-fetch-latest-git-deps",
+      `--profile=${profile ?? "default"}`,
+    ];
+
+    const addressesMap = this.parseNamedAddresses(namedAddresses);
+
+    cliArgs.push(...this.prepareNamedAddresses(addressesMap));
+
+    return this.runCommand(cliArgs);
+  }
+
+  /**
+   * Run a move command
+   *
+   * @param args
+   * @returns
+   */
+  // eslint-disable-next-line class-methods-use-this
+  private async runCommand(args: Array<string>): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      const childProcess = spawn("npx", args);
+
+      childProcess.stdout.pipe(process.stdout);
+      childProcess.stderr.pipe(process.stderr);
+      process.stdin.pipe(childProcess.stdin);
+
+      childProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve(true); // Resolve with true if the child process exits successfully
+        } else {
+          reject(new Error(`Child process exited with code ${code}`)); // Reject with an error if the child process exits with an error code
+        }
+      });
+    });
+  }
+
+  /**
+   * Convert named addresses from a Map into an array seperated by a comma
+   *
+   * @example
+   * input: {'alice' => '0x123', 'bob' => '0x456'}
+   * output: "alice=0x123,bob=0x456"
+   *
+   * @param namedAddresses
+   * @returns An array of names addresses seperated by a comma
+   */
+  // eslint-disable-next-line class-methods-use-this
+  private prepareNamedAddresses(namedAddresses: Map<string, AccountAddress>): Array<string> {
+    const totalNames = namedAddresses.size;
+    const newArgs: Array<string> = [];
+
+    if (totalNames === 0) {
+      return newArgs;
+    }
+
+    newArgs.push("--named-addresses");
+
+    let idx = 0;
+    namedAddresses.forEach((value, key) => {
+      idx += 1;
+      let toAppend = `${key}=${value.toString()}`;
+      if (idx < totalNames - 1) {
+        toAppend += ",";
+      }
+      newArgs.push(toAppend);
+    });
+    return newArgs;
+  }
+
+  /**
+   * Parse named addresses from a Record type into a Map
+   *
+   * @param namedAddresses
+   * @returns Map<name,address>
+   */
+  // eslint-disable-next-line class-methods-use-this
+  private parseNamedAddresses(namedAddresses: Record<string, AccountAddress>): Map<string, AccountAddress> {
+    const addressesMap = new Map();
+
+    Object.keys(namedAddresses).forEach((key) => {
+      const address = namedAddresses[key];
+      addressesMap.set(key, address);
+    });
+
+    return addressesMap;
+  }
+}

package/src/core/crypto/hdKey.ts

@@ -105,11 +105,11 @@ export function fromDerivationPath(
   seed: Uint8Array,
   offset = HARDENED_OFFSET,
 ): Uint8Array {
-  if (offset === HARDENED_OFFSET && !isValidHardenedPath(path)) {
-    throw new Error(`Invalid hardened derivation path ${path}`);
-  } else if (offset !== HARDENED_OFFSET && !isValidBIP44Path(path)) {
-    throw new Error(`Invalid derivation path ${path}`);
-  }
+  // if (offset === HARDENED_OFFSET && !isValidHardenedPath(path)) {
+  //   throw new Error(`Invalid hardened derivation path ${path}`);
+  // } else if (offset !== HARDENED_OFFSET && !isValidBIP44Path(path)) {
+  //   throw new Error(`Invalid derivation path ${path}`);
+  // }
   const { key, chainCode } = deriveKey(hashSeed, seed);
 
   const segments = splitPath(path).map((el) => parseInt(el, 10));

package/src/core/crypto/multiKey.ts

@@ -140,6 +140,12 @@ export class MultiKey extends AccountPublicKey {
     return bitmap;
   }
 
+  /**
+   * Get the index of the provided public key.
+   *
+   * @param publicKey array of the index mapping to the matching public keys
+   * @returns the corresponding index of the publicKey, if it exists
+   */
   getIndex(publicKey: PublicKey): number {
     const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
     const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());
@@ -151,7 +157,7 @@ export class MultiKey extends AccountPublicKey {
   }
 }
 
-export class MultiSignature extends Signature {
+export class MultiKeySignature extends Signature {
   /**
    * Number of bytes in the bitmap representing who signed the transaction (32-bits)
    */
@@ -160,7 +166,7 @@ export class MultiSignature extends Signature {
   /**
    * Maximum number of Ed25519 signatures supported
    */
-  static MAX_SIGNATURES_SUPPORTED = MultiSignature.BITMAP_LEN * 8;
+  static MAX_SIGNATURES_SUPPORTED = MultiKeySignature.BITMAP_LEN * 8;
 
   /**
    * The list of underlying Ed25519 signatures
@@ -188,8 +194,8 @@ export class MultiSignature extends Signature {
     super();
     const { signatures, bitmap } = args;
 
-    if (signatures.length > MultiSignature.MAX_SIGNATURES_SUPPORTED) {
-      throw new Error(`The number of signatures cannot be greater than ${MultiSignature.MAX_SIGNATURES_SUPPORTED}`);
+    if (signatures.length > MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
+      throw new Error(`The number of signatures cannot be greater than ${MultiKeySignature.MAX_SIGNATURES_SUPPORTED}`);
     }
 
     // Make sure that all signatures are normalized to the SingleKey authentication scheme
@@ -198,9 +204,9 @@ export class MultiSignature extends Signature {
     );
 
     if (!(bitmap instanceof Uint8Array)) {
-      this.bitmap = MultiSignature.createBitmap({ bits: bitmap });
-    } else if (bitmap.length !== MultiSignature.BITMAP_LEN) {
-      throw new Error(`"bitmap" length should be ${MultiSignature.BITMAP_LEN}`);
+      this.bitmap = MultiKeySignature.createBitmap({ bits: bitmap });
+    } else if (bitmap.length !== MultiKeySignature.BITMAP_LEN) {
+      throw new Error(`"bitmap" length should be ${MultiKeySignature.BITMAP_LEN}`);
     } else {
       this.bitmap = bitmap;
     }
@@ -236,8 +242,8 @@ export class MultiSignature extends Signature {
     const dupCheckSet = new Set();
 
     bits.forEach((bit: number) => {
-      if (bit >= MultiSignature.MAX_SIGNATURES_SUPPORTED) {
-        throw new Error(`Cannot have a signature larger than ${MultiSignature.MAX_SIGNATURES_SUPPORTED - 1}.`);
+      if (bit >= MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
+        throw new Error(`Cannot have a signature larger than ${MultiKeySignature.MAX_SIGNATURES_SUPPORTED - 1}.`);
       }
 
       if (dupCheckSet.has(bit)) {
@@ -275,15 +281,10 @@ export class MultiSignature extends Signature {
     serializer.serializeBytes(this.bitmap);
   }
 
-  static deserialize(deserializer: Deserializer): MultiSignature {
+  static deserialize(deserializer: Deserializer): MultiKeySignature {
+    const signatures = deserializer.deserializeVector(AnySignature);
     const bitmap = deserializer.deserializeBytes();
-    const nSignatures = bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);
-    const signatures: AnySignature[] = [];
-    for (let i = 0; i < nSignatures; i += 1) {
-      const signature = AnySignature.deserialize(deserializer);
-      signatures.push(signature);
-    }
-    return new MultiSignature({ signatures, bitmap });
+    return new MultiKeySignature({ signatures, bitmap });
   }
 
   // endregion

package/src/internal/ans.ts

@@ -79,7 +79,6 @@ const NetworkToAnsContract: Record<Network, string | null> = {
   [Network.LOCAL]: LOCAL_ANS_ACCOUNT_ADDRESS,
   [Network.CUSTOM]: null,
   [Network.DEVNET]: null,
-  [Network.RANDOMNET]: null,
 };
 
 function getRouterAddress(aptosConfig: AptosConfig): string {

package/src/internal/fungibleAsset.ts

@@ -118,7 +118,7 @@ export async function getCurrentFungibleAssetBalances(args: {
 }
 
 const faTransferAbi: EntryFunctionABI = {
-  typeParameters: [],
+  typeParameters: [{ constraints: [] }],
   parameters: [parseTypeTag("0x1::object::Object"), new TypeTagAddress(), new TypeTagU64()],
 };
 

package/src/internal/transactionSubmission.ts

@@ -203,7 +203,7 @@ export function getSigningMessage(args: { transaction: AnyRawTransaction }): Uin
  */
 export function signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
   const { signer, transaction } = args;
-  return signer.signWithAuthenticator(transaction);
+  return signer.signTransactionWithAuthenticator(transaction);
 }
 
 /**

package/src/transactions/authenticator/account.ts

@@ -7,7 +7,7 @@ import { Serializer, Deserializer, Serializable } from "../../bcs";
 import { AnyPublicKey, AnySignature } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
-import { MultiKey, MultiSignature } from "../../core/crypto/multiKey";
+import { MultiKey, MultiKeySignature } from "../../core/crypto/multiKey";
 import { AccountAuthenticatorVariant } from "../../types";
 
 export abstract class AccountAuthenticator extends Serializable {
@@ -149,9 +149,9 @@ export class AccountAuthenticatorSingleKey extends AccountAuthenticator {
 export class AccountAuthenticatorMultiKey extends AccountAuthenticator {
   public readonly public_keys: MultiKey;
 
-  public readonly signatures: MultiSignature;
+  public readonly signatures: MultiKeySignature;
 
-  constructor(public_keys: MultiKey, signatures: MultiSignature) {
+  constructor(public_keys: MultiKey, signatures: MultiKeySignature) {
     super();
     this.public_keys = public_keys;
     this.signatures = signatures;
@@ -165,7 +165,7 @@ export class AccountAuthenticatorMultiKey extends AccountAuthenticator {
 
   static load(deserializer: Deserializer): AccountAuthenticatorMultiKey {
     const public_keys = MultiKey.deserialize(deserializer);
-    const signatures = MultiSignature.deserialize(deserializer);
+    const signatures = MultiKeySignature.deserialize(deserializer);
     return new AccountAuthenticatorMultiKey(public_keys, signatures);
   }
 }