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

package/src/{core/account → account}/SingleKeyAccount.ts

@@ -1,8 +1,10 @@
-import { AccountAuthenticatorSingleKey } from "../../transactions/authenticator/account";
-import { type HexInput, SigningScheme, SigningSchemeInput } from "../../types";
-import { AccountAddress, AccountAddressInput } from "../accountAddress";
-import { AnyPublicKey, AnySignature, Ed25519PrivateKey, PrivateKey, Secp256k1PrivateKey } from "../crypto";
+import { AccountAuthenticatorSingleKey } from "../transactions/authenticator/account";
+import { type HexInput, SigningScheme, SigningSchemeInput } from "../types";
+import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
+import { AnyPublicKey, AnySignature, Ed25519PrivateKey, PrivateKey, Secp256k1PrivateKey } from "../core/crypto";
 import type { Account } from "./Account";
+import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
+import { AnyRawTransaction } from "../transactions/types";
 
 export interface SingleKeySignerConstructorArgs {
   privateKey: PrivateKey;
@@ -102,18 +104,51 @@ 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(message: HexInput) {
-    const innerSignature = this.privateKey.sign(message);
-    const signature = new AnySignature(innerSignature);
-    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) {
-    return this.signWithAuthenticator(message).signature;
+  /**
+   * 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));
+  }
+
+  /**
+   * 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));
   }
 
   // endregion

package/src/account/index.ts

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

package/src/api/account.ts

@@ -1,7 +1,8 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AccountAddress, PrivateKey, Account as AccountModule, AccountAddressInput } from "../core";
+import { Account as AccountModule } from "../account";
+import { AccountAddress, PrivateKey, AccountAddressInput } from "../core";
 import {
   AccountData,
   AnyNumber,

package/src/api/ans.ts

@@ -1,7 +1,8 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account, AccountAddress, AccountAddressInput } from "../core";
+import { Account } from "../account";
+import { AccountAddress, AccountAddressInput } from "../core";
 import {
   RegisterNameParameters,
   getExpiration,

package/src/api/aptos.ts

@@ -12,6 +12,7 @@ import { General } from "./general";
 import { ANS } from "./ans";
 import { Staking } from "./staking";
 import { Transaction } from "./transaction";
+import { Keyless } from "./keyless";
 
 /**
  * This class is the main entry point into Aptos's
@@ -47,6 +48,8 @@ export class Aptos {
 
   readonly transaction: Transaction;
 
+  readonly keyless: Keyless;
+
   constructor(settings?: AptosConfig) {
     this.config = new AptosConfig(settings);
     this.account = new Account(this.config);
@@ -59,6 +62,7 @@ export class Aptos {
     this.general = new General(this.config);
     this.staking = new Staking(this.config);
     this.transaction = new Transaction(this.config);
+    this.keyless = new Keyless(this.config);
   }
 }
 
@@ -73,6 +77,7 @@ export interface Aptos
     Faucet,
     FungibleAsset,
     General,
+    Keyless,
     Staking,
     Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {}
 
@@ -107,3 +112,4 @@ applyMixin(Aptos, FungibleAsset, "fungibleAsset");
 applyMixin(Aptos, General, "general");
 applyMixin(Aptos, Staking, "staking");
 applyMixin(Aptos, Transaction, "transaction");
+applyMixin(Aptos, Keyless, "keyless");

package/src/api/aptosConfig.ts

@@ -3,7 +3,14 @@
 
 import aptosClient from "@aptos-labs/aptos-client";
 import { AptosSettings, ClientConfig, Client, FullNodeConfig, IndexerConfig, FaucetConfig } from "../types";
-import { NetworkToNodeAPI, NetworkToFaucetAPI, NetworkToIndexerAPI, Network } from "../utils/apiEndpoints";
+import {
+  NetworkToNodeAPI,
+  NetworkToFaucetAPI,
+  NetworkToIndexerAPI,
+  Network,
+  NetworkToPepperAPI,
+  NetworkToProverAPI,
+} from "../utils/apiEndpoints";
 import { AptosApiType } from "../utils/const";
 
 /**
@@ -34,6 +41,16 @@ export class AptosConfig {
    */
   readonly faucet?: string;
 
+  /**
+   * The optional hardcoded pepper service URL to send requests to instead of using the network
+   */
+  readonly pepper?: string;
+
+  /**
+   * The optional hardcoded prover service URL to send requests to instead of using the network
+   */
+  readonly prover?: string;
+
   /**
    * The optional hardcoded indexer URL to send requests to instead of using the network
    */
@@ -63,6 +80,8 @@ export class AptosConfig {
     this.network = settings?.network ?? Network.DEVNET;
     this.fullnode = settings?.fullnode;
     this.faucet = settings?.faucet;
+    this.pepper = settings?.pepper;
+    this.prover = settings?.prover;
     this.indexer = settings?.indexer;
     this.client = settings?.client ?? { provider: aptosClient };
     this.clientConfig = settings?.clientConfig ?? {};
@@ -95,8 +114,34 @@ export class AptosConfig {
         if (this.indexer !== undefined) return this.indexer;
         if (this.network === Network.CUSTOM) throw new Error("Please provide a custom indexer url");
         return NetworkToIndexerAPI[this.network];
+      case AptosApiType.PEPPER:
+        if (this.pepper !== undefined) return this.pepper;
+        if (this.network === Network.CUSTOM) throw new Error("Please provide a custom pepper service url");
+        return NetworkToPepperAPI[this.network];
+      case AptosApiType.PROVER:
+        if (this.prover !== undefined) return this.prover;
+        if (this.network === Network.CUSTOM) throw new Error("Please provide a custom prover service url");
+        return NetworkToProverAPI[this.network];
       default:
         throw Error(`apiType ${apiType} is not supported`);
     }
   }
+
+  /**
+   * Checks if the URL is a known pepper service endpoint
+   *
+   * @internal
+   * */
+  isPepperServiceRequest(url: string): boolean {
+    return NetworkToPepperAPI[this.network] === url;
+  }
+
+  /**
+   * Checks if the URL is a known prover service endpoint
+   *
+   * @internal
+   * */
+  isProverServiceRequest(url: string): boolean {
+    return NetworkToProverAPI[this.network] === url;
+  }
 }

package/src/api/digitalAsset.ts

@@ -13,7 +13,8 @@ import {
   PaginationArgs,
   TokenStandardArg,
 } from "../types";
-import { Account, AccountAddress, AccountAddressInput } from "../core";
+import { AccountAddress, AccountAddressInput } from "../core";
+import { Account } from "../account";
 import { InputGenerateTransactionOptions } from "../transactions/types";
 import {
   addDigitalAssetPropertyTransaction,

package/src/api/fungibleAsset.ts

@@ -23,7 +23,8 @@ import {
 import { ProcessorType } from "../utils/const";
 import { AptosConfig } from "./aptosConfig";
 import { waitForIndexerOnVersion } from "./utils";
-import { Account, AccountAddressInput } from "../core";
+import { Account } from "../account";
+import { AccountAddressInput } from "../core";
 import { InputGenerateTransactionOptions } from "../transactions";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 

package/src/api/keyless.ts

@@ -0,0 +1,48 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
+import { deriveKeylessAccount, getPepper } from "../internal/keyless";
+import { HexInput } from "../types";
+import { AptosConfig } from "./aptosConfig";
+
+/**
+ * A class to query all `Keyless` related queries on Aptos.
+ */
+export class Keyless {
+  constructor(readonly config: AptosConfig) {}
+
+  /**
+   * Fetches the pepper from the Aptos pepper service API.
+   *
+   * @param args.jwt JWT token
+   * @param args.ephemeralKeyPair the EphemeralKeyPair used to generate the nonce in the JWT token
+   * @returns The pepper which is a Uint8Array of length 31.
+   */
+  async getPepper(args: { jwt: string; ephemeralKeyPair: EphemeralKeyPair }): Promise<Uint8Array> {
+    return getPepper({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Fetches the pepper from the Aptos pepper service API.
+   *
+   * @param args.jwt JWT token
+   * @param args.ephemeralKeyPair the EphemeralKeyPair used to generate the nonce in the JWT token
+   * @param args.uidKey a key in the JWT token to use to set the uidVal in the IdCommitment
+   * @param args.pepper the pepper
+   * @param args.extraFieldKey a key in the JWT token used to reveal a value on chain
+   * @param args.proofFetchCallback a callback function that if set, the fetch of the proof will be done asyncronously. Once
+   * if finishes the callback function will be called.
+   * @returns A KeylessAccount that can be used to sign transactions
+   */
+  async deriveKeylessAccount(args: {
+    jwt: string;
+    ephemeralKeyPair: EphemeralKeyPair;
+    uidKey?: string;
+    pepper?: HexInput;
+    extraFieldKey?: string;
+    proofFetchCallback?: ProofFetchCallback;
+  }): Promise<KeylessAccount> {
+    return deriveKeylessAccount({ aptosConfig: this.config, ...args });
+  }
+}

package/src/api/transaction.ts

@@ -33,7 +33,8 @@ import {
   InputGenerateTransactionOptions,
   InputGenerateTransactionPayloadData,
 } from "../transactions";
-import { AccountAddressInput, Account, PrivateKey } from "../core";
+import { AccountAddressInput, PrivateKey } from "../core";
+import { Account } from "../account";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";

package/src/api/transactionSubmission/management.ts

@@ -2,7 +2,7 @@ import EventEmitter from "eventemitter3";
 import { TransactionWorkerEvents, TransactionWorker, TransactionWorkerEventsEnum } from "../../transactions/management";
 import { InputGenerateTransactionPayloadData, InputGenerateTransactionOptions } from "../../transactions";
 import { AptosConfig } from "../aptosConfig";
-import { Account } from "../../core";
+import { Account } from "../../account";
 
 export class TransactionManagement extends EventEmitter<TransactionWorkerEvents> {
   account!: Account;

package/src/api/transactionSubmission/sign.ts

@@ -1,7 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account } from "../../core";
+import { Account } from "../../account";
 import { signTransaction } from "../../internal/transactionSubmission";
 import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
 import { AptosConfig } from "../aptosConfig";

package/src/bcs/deserializer.ts

@@ -56,6 +56,46 @@ export class Deserializer {
     return textDecoder.decode(value);
   }
 
+  /**
+   * Deserializes a an optional string.
+   *
+   * BCS layout for Optional<String>: 0 if none, else 1 | string_length | string_content
+   * @example
+   * ```ts
+   * const deserializer = new Deserializer(new Uint8Array([0x00]));
+   * assert(deserializer.deserializeOptionStr() === undefined);
+   * const deserializer = new Deserializer(new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
+   * assert(deserializer.deserializeOptionStr() === "1234abcd");
+   * ```
+   */
+  deserializeOptionStr(): string | undefined {
+    const exists = this.deserializeUleb128AsU32();
+    if (exists === 1) {
+      return this.deserializeStr();
+    }
+    return undefined;
+  }
+
+  /**
+   * Deserializes a an optional string.
+   *
+   * BCS layout for Optional<String>: 0 if none, else 1 | string_length | string_content
+   * @example
+   * ```ts
+   * const deserializer = new Deserializer(new Uint8Array([0x00]));
+   * assert(deserializer.deserializeOptionStr() === undefined);
+   * const deserializer = new Deserializer(new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
+   * assert(deserializer.deserializeOptionStr() === "1234abcd");
+   * ```
+   */
+  deserializeOption<T>(cls: Deserializable<T>): T | undefined {
+    const exists = this.deserializeUleb128AsU32();
+    if (exists === 1) {
+      return this.deserialize(cls);
+    }
+    return undefined;
+  }
+
   /**
    * Deserializes an array of bytes.
    *

package/src/bcs/serializer.ts

@@ -316,6 +316,24 @@ export class Serializer {
       item.serialize(this);
     });
   }
+
+  serializeOption<T extends Serializable>(value?: T): void {
+    if (value === undefined) {
+      this.serializeU32AsUleb128(0);
+    } else {
+      this.serializeU32AsUleb128(1);
+      value.serialize(this);
+    }
+  }
+
+  serializeOptionStr(value?: string): void {
+    if (value === undefined) {
+      this.serializeU32AsUleb128(0);
+    } else {
+      this.serializeU32AsUleb128(1);
+      this.serializeStr(value);
+    }
+  }
 }
 
 export function ensureBoolean(value: unknown): asserts value is boolean {

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/client/core.ts

@@ -106,6 +106,14 @@ export async function aptosRequest<Req extends {}, Res extends {}>(
     return result;
   }
 
+  if (result.status >= 500) {
+    throw new AptosApiError(options, result, `${response.data}`);
+  }
+
+  if (aptosConfig.isPepperServiceRequest(url) || aptosConfig.isProverServiceRequest(url)) {
+    throw new AptosApiError(options, result, `${response.data}`);
+  }
+
   let errorMessage: string;
 
   if (result && result.data && "message" in result.data && "error_code" in result.data) {

package/src/client/get.ts

@@ -89,6 +89,12 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
+export async function getAptosPepperService<Req extends {}, Res extends {}>(
+  options: GetAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
+  return get<Req, Res>({ ...options, type: AptosApiType.PEPPER });
+}
+
 /// This function is a helper for paginating using a function wrapping an API
 export async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,

package/src/client/post.ts

@@ -135,3 +135,15 @@ export async function postAptosFaucet<Req extends {}, Res extends {}>(
     },
   });
 }
+
+export async function postAptosPepperService<Req extends {}, Res extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
+  return post<Req, Res>({ ...options, type: AptosApiType.PEPPER });
+}
+
+export async function postAptosProvingService<Req extends {}, Res extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
+  return post<Req, Res>({ ...options, type: AptosApiType.PROVER });
+}

package/src/client/types.ts

@@ -41,7 +41,7 @@ export class AptosApiError extends Error {
 
   readonly statusText: string;
 
-  readonly data: any;
+  readonly data: { message: string; error_code?: string; vm_error_code?: number };
 
   readonly request: AptosRequest;
 

package/src/core/account/index.ts

@@ -1,4 +1 @@
-export * from "./Ed25519Account";
-export * from "./Account";
-export * from "./SingleKeyAccount";
 export * from "./utils";