@aptos-labs/ts-sdk 1.17.0 → 1.18.1

package/src/core/crypto/poseidon.ts

@@ -0,0 +1,144 @@
+/* eslint-disable no-bitwise */
+import {
+  poseidon1,
+  poseidon2,
+  poseidon3,
+  poseidon4,
+  poseidon5,
+  poseidon6,
+  poseidon7,
+  poseidon8,
+  poseidon9,
+  poseidon10,
+  poseidon11,
+  poseidon12,
+  poseidon13,
+  poseidon14,
+  poseidon15,
+  poseidon16,
+} from "poseidon-lite";
+
+const numInputsToPoseidonFunc = [
+  poseidon1,
+  poseidon2,
+  poseidon3,
+  poseidon4,
+  poseidon5,
+  poseidon6,
+  poseidon7,
+  poseidon8,
+  poseidon9,
+  poseidon10,
+  poseidon11,
+  poseidon12,
+  poseidon13,
+  poseidon14,
+  poseidon15,
+  poseidon16,
+];
+
+const BYTES_PACKED_PER_SCALAR = 31;
+const MAX_NUM_INPUT_SCALARS = 16;
+const MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
+
+/**
+ * Hashes a string to a field element via poseidon
+ *
+ * @returns bigint result of the hash
+ */
+export function hashStrToField(str: string, maxSizeBytes: number): bigint {
+  const textEncoder = new TextEncoder();
+  const strBytes = textEncoder.encode(str);
+  return hashBytesWithLen(strBytes, maxSizeBytes);
+}
+
+function hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);
+  return poseidonHash(packed);
+}
+
+function padAndPackBytesNoLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);
+  return packBytes(paddedStrBytes);
+}
+
+export function padAndPackBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
+}
+
+function packBytes(bytes: Uint8Array): bigint[] {
+  if (bytes.length > MAX_NUM_INPUT_BYTES) {
+    throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
+  }
+  return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
+}
+
+function chunkUint8Array(array: Uint8Array, chunkSize: number): Uint8Array[] {
+  const result: Uint8Array[] = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.subarray(i, i + chunkSize));
+  }
+  return result;
+}
+
+export function bytesToBigIntLE(bytes: Uint8Array): bigint {
+  let result = BigInt(0);
+  for (let i = bytes.length - 1; i >= 0; i -= 1) {
+    result = (result << BigInt(8)) | BigInt(bytes[i]);
+  }
+  return result;
+}
+
+export function bigIntToBytesLE(value: bigint, length: number): Uint8Array {
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i += 1) {
+    bytes[i] = Number(value & BigInt(0xff));
+    // eslint-disable-next-line no-param-reassign
+    value >>= BigInt(8);
+  }
+  return bytes;
+}
+
+function padUint8ArrayWithZeros(inputArray: Uint8Array, paddedSize: number): Uint8Array {
+  if (paddedSize < inputArray.length) {
+    throw new Error("Padded size must be greater than or equal to the input array size.");
+  }
+
+  // Create a new Uint8Array with the padded size
+  const paddedArray = new Uint8Array(paddedSize);
+
+  // Copy the content of the input array to the new array
+  paddedArray.set(inputArray);
+
+  // Fill the remaining space with zeros
+  for (let i = inputArray.length; i < paddedSize; i += 1) {
+    paddedArray[i] = 0;
+  }
+
+  return paddedArray;
+}
+
+/**
+ * Hashes up to 16 scalar elements via the poseidon hashing algorithm.
+ *
+ * Each element must be scalar fields of the BN254 elliptic curve group.
+ *
+ * @returns bigint result of the hash
+ */
+export function poseidonHash(inputs: (number | bigint | string)[]): bigint {
+  if (inputs.length > numInputsToPoseidonFunc.length) {
+    throw new Error(
+      `Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`,
+    );
+  }
+  return numInputsToPoseidonFunc[inputs.length - 1](inputs);
+}

package/src/core/crypto/proof.ts

@@ -0,0 +1,16 @@
+import { Serializable } from "../../bcs";
+import { Hex } from "../hex";
+
+/**
+ * An abstract representation of a crypto proof.
+ * associated to a specific zero knowledge proof schemes e.g. Groth16, PLONK
+ */
+export abstract class Proof extends Serializable {
+  /**
+   * Get the proof as a hex string with a 0x prefix e.g. 0x123456...
+   */
+  toString(): string {
+    const bytes = this.bcsToBytes();
+    return Hex.fromHexInput(bytes).toString();
+  }
+}

package/src/core/crypto/singleKey.ts

@@ -4,6 +4,7 @@ import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
 import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
 import { Secp256k1PublicKey, Secp256k1Signature } from "./secp256k1";
+import { KeylessPublicKey, KeylessSignature } from "./keyless";
 import { Signature } from "./signature";
 
 /**
@@ -34,6 +35,8 @@ export class AnyPublicKey extends AccountPublicKey {
       this.variant = AnyPublicKeyVariant.Ed25519;
     } else if (publicKey instanceof Secp256k1PublicKey) {
       this.variant = AnyPublicKeyVariant.Secp256k1;
+    } else if (publicKey instanceof KeylessPublicKey) {
+      this.variant = AnyPublicKeyVariant.Keyless;
     } else {
       throw new Error("Unsupported public key type");
     }
@@ -85,6 +88,9 @@ export class AnyPublicKey extends AccountPublicKey {
       case AnyPublicKeyVariant.Secp256k1:
         publicKey = Secp256k1PublicKey.deserialize(deserializer);
         break;
+      case AnyPublicKeyVariant.Keyless:
+        publicKey = KeylessPublicKey.deserialize(deserializer);
+        break;
       default:
         throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
     }
@@ -138,6 +144,8 @@ export class AnySignature extends Signature {
       this.variant = AnySignatureVariant.Ed25519;
     } else if (signature instanceof Secp256k1Signature) {
       this.variant = AnySignatureVariant.Secp256k1;
+    } else if (signature instanceof KeylessSignature) {
+      this.variant = AnySignatureVariant.Keyless;
     } else {
       throw new Error("Unsupported signature type");
     }
@@ -170,6 +178,9 @@ export class AnySignature extends Signature {
       case AnySignatureVariant.Secp256k1:
         signature = Secp256k1Signature.deserialize(deserializer);
         break;
+      case AnySignatureVariant.Keyless:
+        signature = KeylessSignature.deserialize(deserializer);
+        break;
       default:
         throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
     }

package/src/internal/keyless.ts

@@ -0,0 +1,129 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/keyless}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * keyless namespace and without having a dependency cycle error.
+ */
+import { AptosConfig } from "../api/aptosConfig";
+import { postAptosPepperService, postAptosProvingService } from "../client";
+import {
+  EphemeralSignature,
+  Groth16Zkp,
+  Hex,
+  KeylessPublicKey,
+  ZeroKnowledgeSig,
+  ZkProof,
+  getKeylessConfig,
+} from "../core";
+import { HexInput, ZkpVariant } from "../types";
+import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
+import { PepperFetchRequest, PepperFetchResponse, ProverRequest, ProverResponse } from "../types/keyless";
+import { nowInSeconds } from "../utils/helpers";
+import { lookupOriginalAccountAddress } from "./account";
+
+export async function getPepper(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  derivationPath?: string;
+}): Promise<Uint8Array> {
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey = "sub", derivationPath } = args;
+
+  const body = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    uid_key: uidKey,
+    derivation_path: derivationPath,
+  };
+  const { data } = await postAptosPepperService<PepperFetchRequest, PepperFetchResponse>({
+    aptosConfig,
+    path: "fetch",
+    body,
+    originMethod: "getPepper",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+  return Hex.fromHexInput(data.pepper).toUint8Array();
+}
+
+export async function getProof(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  pepper?: HexInput;
+  uidKey?: string;
+}): Promise<ZeroKnowledgeSig> {
+  const { aptosConfig, jwt, ephemeralKeyPair, pepper = await getPepper(args), uidKey = "sub" } = args;
+  if (Hex.fromHexInput(pepper).toUint8Array().length !== KeylessAccount.PEPPER_LENGTH) {
+    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);
+  }
+  const { maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });
+  if (maxExpHorizonSecs < ephemeralKeyPair.expiryDateSecs - nowInSeconds()) {
+    throw Error(`The EphemeralKeyPair is too long lived.  It's lifespan must be less than ${maxExpHorizonSecs}`);
+  }
+  const json = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    exp_horizon_secs: maxExpHorizonSecs,
+    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
+    uid_key: uidKey,
+  };
+
+  const { data } = await postAptosProvingService<ProverRequest, ProverResponse>({
+    aptosConfig,
+    path: "prove",
+    body: json,
+    originMethod: "getProof",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+
+  const proofPoints = data.proof;
+  const groth16Zkp = new Groth16Zkp({
+    a: proofPoints.a,
+    b: proofPoints.b,
+    c: proofPoints.c,
+  });
+
+  const signedProof = new ZeroKnowledgeSig({
+    proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),
+    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),
+    expHorizonSecs: maxExpHorizonSecs,
+  });
+  return signedProof;
+}
+
+export async function deriveKeylessAccount(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<KeylessAccount> {
+  const { aptosConfig, jwt, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;
+  const proofPromise = getProof({ ...args, pepper });
+  // If a callback is provided, pass in the proof as a promise to KeylessAccount.create.  This will make the proof be fetched in the
+  // background and the callback will handle the outcome of the fetch.  This allows the developer to not have to block on the proof fetch
+  // allowing for faster rendering of UX.
+  //
+  // If no callback is provided, the just await the proof fetch and continue syncronously.
+  const proof = proofFetchCallback ? proofPromise : await proofPromise;
+
+  // Look up the original address to handle key rotations
+  const publicKey = KeylessPublicKey.fromJwtAndPepper({ jwt, pepper, uidKey });
+  const address = await lookupOriginalAccountAddress({
+    aptosConfig,
+    authenticationKey: publicKey.authKey().derivedAddress(),
+  });
+
+  const keylessAccount = KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback });
+
+  return keylessAccount;
+}

package/src/internal/queries/getFungibleAssetMetadata.graphql

@@ -12,5 +12,7 @@ query getFungibleAssetMetadata($where_condition: fungible_asset_metadata_bool_ex
     name
     symbol
     token_standard
+    supply_v2
+    maximum_v2
   }
 }

package/src/internal/transactionSubmission.ts

@@ -8,7 +8,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveVector, U8 } from "../bcs";
 import { postAptosFullNode } from "../client";
-import { Account } from "../account";
+import { Account, KeylessAccount, MultiKeyAccount } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { PrivateKey } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
@@ -275,6 +275,11 @@ export async function signAndSubmitTransaction(args: {
   transaction: AnyRawTransaction;
 }): Promise<PendingTransactionResponse> {
   const { aptosConfig, signer, transaction } = args;
+  // If the signer contains a KeylessAccount, await proof fetching in case the proof
+  // was fetched asyncronously.
+  if (signer instanceof KeylessAccount || signer instanceof MultiKeyAccount) {
+    await signer.waitForProofFetch();
+  }
   const authenticator = signTransaction({ signer, transaction });
   return submitTransaction({
     aptosConfig,

package/src/transactions/management/accountSequenceNumber.ts

@@ -26,10 +26,7 @@
 import { AptosConfig } from "../../api/aptosConfig";
 import { Account } from "../../account";
 import { getInfo } from "../../internal/account";
-import { sleep } from "../../utils/helpers";
-
-// returns `now` time in seconds
-const now = () => Math.floor(Date.now() / 1000);
+import { nowInSeconds, sleep } from "../../utils/helpers";
 
 export class AccountSequenceNumber {
   readonly aptosConfig: AptosConfig;
@@ -96,10 +93,10 @@ export class AccountSequenceNumber {
       if (this.currentNumber! - this.lastUncommintedNumber! >= this.maximumInFlight) {
         await this.update();
 
-        const startTime = now();
+        const startTime = nowInSeconds();
         while (this.currentNumber! - this.lastUncommintedNumber! >= this.maximumInFlight) {
           await sleep(this.sleepTime);
-          if (now() - startTime > this.maxWaitTime) {
+          if (nowInSeconds() - startTime > this.maxWaitTime) {
             /* eslint-disable no-console */
             console.warn(
               `Waited over 30 seconds for a transaction to commit, resyncing ${this.account.accountAddress.toString()}`,
@@ -164,9 +161,9 @@ export class AccountSequenceNumber {
 
     try {
       await this.update();
-      const startTime = now();
+      const startTime = nowInSeconds();
       while (this.lastUncommintedNumber !== this.currentNumber) {
-        if (now() - startTime > this.maxWaitTime) {
+        if (nowInSeconds() - startTime > this.maxWaitTime) {
           /* eslint-disable no-console */
           console.warn(
             `Waited over 30 seconds for a transaction to commit, resyncing ${this.account.accountAddress.toString()}`,

package/src/transactions/transactionBuilder/signingMessage.ts

@@ -61,6 +61,9 @@ export function generateSigningMessage(bytes: Uint8Array, domainSeparator: strin
 }
 
 /**
+ * @deprecated
+ * Use CryptoHashable instead by having your class implement it and call hash() to get the signing message.
+ *
  * Generates the 'signing message' form of a serilizable value. It bcs serializes the value and uses the name of
  * its constructor as the domain separator.
  *

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -9,7 +9,14 @@
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { AptosConfig } from "../../api/aptosConfig";
 import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core";
-import { AnyPublicKey, AnySignature, Secp256k1PublicKey, Secp256k1Signature } from "../../core/crypto";
+import {
+  AnyPublicKey,
+  AnySignature,
+  KeylessPublicKey,
+  KeylessSignature,
+  Secp256k1PublicKey,
+  Secp256k1Signature,
+} from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { getInfo } from "../../internal/account";
 import { getLedgerInfo } from "../../internal/general";
@@ -445,6 +452,11 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
 }
 
 export function getAuthenticatorForSimulation(publicKey: PublicKey) {
+  if (publicKey instanceof KeylessPublicKey || publicKey instanceof Secp256k1PublicKey) {
+    // eslint-disable-next-line no-param-reassign
+    publicKey = new AnyPublicKey(publicKey);
+  }
+
   // TODO add support for AnyMultiKey
   if (publicKey instanceof AnyPublicKey) {
     if (publicKey.publicKey instanceof Ed25519PublicKey) {
@@ -453,6 +465,9 @@ export function getAuthenticatorForSimulation(publicKey: PublicKey) {
     if (publicKey.publicKey instanceof Secp256k1PublicKey) {
       return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Secp256k1Signature(new Uint8Array(64))));
     }
+    if (publicKey.publicKey instanceof KeylessPublicKey) {
+      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(KeylessSignature.getSimulationSignature()));
+    }
   }
 
   // legacy code

package/src/types/generated/operations.ts

@@ -49,13 +49,13 @@ export type CurrentTokenOwnershipFieldsFragment = {
     last_transaction_timestamp: any;
     last_transaction_version: any;
     maximum?: any | null;
-    supply: any;
+    supply?: any | null;
     token_data_id: string;
     token_name: string;
     token_properties: any;
     token_standard: string;
     token_uri: string;
-    decimals: any;
+    decimals?: any | null;
     current_collection?: {
       collection_id: string;
       collection_name: string;
@@ -206,13 +206,13 @@ export type GetAccountOwnedTokensQuery = {
       last_transaction_timestamp: any;
       last_transaction_version: any;
       maximum?: any | null;
-      supply: any;
+      supply?: any | null;
       token_data_id: string;
       token_name: string;
       token_properties: any;
       token_standard: string;
       token_uri: string;
-      decimals: any;
+      decimals?: any | null;
       current_collection?: {
         collection_id: string;
         collection_name: string;
@@ -262,13 +262,13 @@ export type GetAccountOwnedTokensByTokenDataQuery = {
       last_transaction_timestamp: any;
       last_transaction_version: any;
       maximum?: any | null;
-      supply: any;
+      supply?: any | null;
       token_data_id: string;
       token_name: string;
       token_properties: any;
       token_standard: string;
       token_uri: string;
-      decimals: any;
+      decimals?: any | null;
       current_collection?: {
         collection_id: string;
         collection_name: string;
@@ -318,13 +318,13 @@ export type GetAccountOwnedTokensFromCollectionQuery = {
       last_transaction_timestamp: any;
       last_transaction_version: any;
       maximum?: any | null;
-      supply: any;
+      supply?: any | null;
       token_data_id: string;
       token_name: string;
       token_properties: any;
       token_standard: string;
       token_uri: string;
-      decimals: any;
+      decimals?: any | null;
       current_collection?: {
         collection_id: string;
         collection_name: string;
@@ -496,6 +496,8 @@ export type GetFungibleAssetMetadataQuery = {
     name: string;
     symbol: string;
     token_standard: string;
+    supply_v2?: any | null;
+    maximum_v2?: any | null;
   }>;
 };
 
@@ -620,13 +622,13 @@ export type GetCurrentTokenOwnershipQuery = {
       last_transaction_timestamp: any;
       last_transaction_version: any;
       maximum?: any | null;
-      supply: any;
+      supply?: any | null;
       token_data_id: string;
       token_name: string;
       token_properties: any;
       token_standard: string;
       token_uri: string;
-      decimals: any;
+      decimals?: any | null;
       current_collection?: {
         collection_id: string;
         collection_name: string;
@@ -663,13 +665,13 @@ export type GetTokenDataQuery = {
     last_transaction_timestamp: any;
     last_transaction_version: any;
     maximum?: any | null;
-    supply: any;
+    supply?: any | null;
     token_data_id: string;
     token_name: string;
     token_properties: any;
     token_standard: string;
     token_uri: string;
-    decimals: any;
+    decimals?: any | null;
     current_collection?: {
       collection_id: string;
       collection_name: string;