@aptos-labs/ts-sdk 1.15.0 → 1.16.0-zeta.1

package/src/core/crypto/poseidon.ts

@@ -0,0 +1,142 @@
+/* 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,175 @@
+// 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 { getAptosFullNode, postAptosPepperService, postAptosProvingService } from "../client";
+import {
+  AccountAddress,
+  EPK_HORIZON_SECS,
+  EphemeralSignature,
+  Groth16Zkp,
+  Hex,
+  KeylessConfiguration,
+  ZeroKnowledgeSig,
+  ZkProof,
+} from "../core";
+import { HexInput, LedgerVersionArg, MoveResource, ZkpVariant } from "../types";
+import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
+import {
+  Groth16VerificationKeyResponse,
+  KeylessConfigurationResponse,
+  PepperFetchRequest,
+  PepperFetchResponse,
+  ProverRequest,
+  ProverResponse,
+} from "../types/keyless";
+import { memoizeAsync } from "../utils/memoize";
+
+export async function getKeylessConfig(args: {
+  aptosConfig: AptosConfig;
+  options?: LedgerVersionArg;
+}): Promise<KeylessConfiguration> {
+  const { aptosConfig } = args;
+  return memoizeAsync(
+    async () => {
+      const config = await getKeylessConfiguration(args);
+      const vk = await getGroth16VerificationKey(args);
+      return KeylessConfiguration.create(vk, Number(config.max_exp_horizon_secs));
+    },
+    `keyless-configuration-${aptosConfig.network}`,
+    1000 * 60 * 5, // 5 minutes
+  )();
+}
+
+async function getKeylessConfiguration(args: {
+  aptosConfig: AptosConfig;
+  options?: LedgerVersionArg;
+}): Promise<KeylessConfigurationResponse> {
+  const { aptosConfig, options } = args;
+  const resourceType = "0x1::keyless_account::Configuration";
+  const { data } = await getAptosFullNode<{}, MoveResource<KeylessConfigurationResponse>>({
+    aptosConfig,
+    originMethod: "getKeylessConfiguration",
+    path: `accounts/${AccountAddress.from("0x1").toString()}/resource/${resourceType}`,
+    params: { ledger_version: options?.ledgerVersion },
+  });
+
+  return data.data;
+}
+
+async function getGroth16VerificationKey(args: {
+  aptosConfig: AptosConfig;
+  options?: LedgerVersionArg;
+}): Promise<Groth16VerificationKeyResponse> {
+  const { aptosConfig, options } = args;
+  const resourceType = "0x1::keyless_account::Groth16VerificationKey";
+  const { data } = await getAptosFullNode<{}, MoveResource<Groth16VerificationKeyResponse>>({
+    aptosConfig,
+    originMethod: "getGroth16VerificationKey",
+    path: `accounts/${AccountAddress.from("0x1").toString()}/resource/${resourceType}`,
+    params: { ledger_version: options?.ledgerVersion },
+  });
+
+  return data.data;
+}
+
+export async function getPepper(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  derivationPath?: string;
+}): Promise<Uint8Array> {
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, 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 || "sub",
+    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, uidKey } = args;
+  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: EPK_HORIZON_SECS,
+    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
+    uid_key: uidKey || "sub",
+  };
+
+  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),
+  });
+  return signedProof;
+}
+
+export async function deriveKeylessAccount(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<KeylessAccount> {
+  const { proofFetchCallback } = args;
+  let { pepper } = args;
+  if (pepper === undefined) {
+    pepper = await getPepper(args);
+  } else {
+    pepper = Hex.fromHexInput(pepper).toUint8Array();
+  }
+
+  if (pepper.length !== KeylessAccount.PEPPER_LENGTH) {
+    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);
+  }
+
+  const proofPromise = getProof({ ...args, pepper });
+  const proof = proofFetchCallback ? proofPromise : await proofPromise;
+
+  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proof, pepper, proofFetchCallback });
+
+  return keylessAccount;
+}

package/src/internal/transactionSubmission.ts

@@ -7,8 +7,8 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveVector, U8 } from "../bcs";
-import { postAptosFullNode } from "../client";
-import { Account } from "../account";
+import { AptosApiError, postAptosFullNode } from "../client";
+import { Account, KeylessAccount, KeylessError, 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/transactionBuilder/remoteAbi.ts

@@ -10,6 +10,7 @@ import {
   EntryFunctionABI,
   ViewFunctionABI,
   FunctionABI,
+  TypeArgument,
 } from "../types";
 import { Bool, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
 import { AccountAddress } from "../../core";
@@ -40,9 +41,9 @@ const TEXT_ENCODER = new TextEncoder();
 /**
  * Convert type arguments to only type tags, allowing for string representations of type tags
  */
-export function standardizeTypeTags(typeArguments?: Array<TypeTag | string>): Array<TypeTag> {
+export function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<TypeTag> {
   return (
-    typeArguments?.map((typeArg: string | TypeTag): TypeTag => {
+    typeArguments?.map((typeArg: TypeArgument): TypeTag => {
       // Convert to TypeTag if it's a string representation
       if (isString(typeArg)) {
         return parseTypeTag(typeArg);
@@ -217,6 +218,10 @@ function parseArg(
     if (isBool(arg)) {
       return new Bool(arg);
     }
+    if (isString(arg)) {
+      if (arg === "true") return new Bool(true);
+      if (arg === "false") return new Bool(false);
+    }
     throwTypeMismatch("boolean", position);
   }
   // TODO: support uint8array?
@@ -230,18 +235,27 @@ function parseArg(
     if (isNumber(arg)) {
       return new U8(arg);
     }
+    if (isString(arg)) {
+      return new U8(Number.parseInt(arg, 10));
+    }
     throwTypeMismatch("number", position);
   }
   if (param.isU16()) {
     if (isNumber(arg)) {
       return new U16(arg);
     }
+    if (isString(arg)) {
+      return new U16(Number.parseInt(arg, 10));
+    }
     throwTypeMismatch("number", position);
   }
   if (param.isU32()) {
     if (isNumber(arg)) {
       return new U32(arg);
     }
+    if (isString(arg)) {
+      return new U32(Number.parseInt(arg, 10));
+    }
     throwTypeMismatch("number", position);
   }
   if (param.isU64()) {

package/src/transactions/transactionBuilder/signingMessage.ts

@@ -8,7 +8,6 @@ import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT } from "../../utils/const";
 import { FeePayerRawTransaction, MultiAgentRawTransaction } from "../instances";
 import { AnyRawTransaction, AnyRawTransactionInstance } from "../types";
-import { Serializable } from "../../bcs";
 
 /**
  * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
@@ -60,18 +59,6 @@ export function generateSigningMessage(bytes: Uint8Array, domainSeparator: strin
   return mergedArray;
 }
 
-/**
- * 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.
- *
- * @param serializable An object that has a bcs serialized form
- *
- * @returns The Uint8Array of the signing message
- */
-export function generateSigningMessageForSerializable(serializable: Serializable): Uint8Array {
-  return generateSigningMessage(serializable.bcsToBytes(), `APTOS::${serializable.constructor.name}`);
-}
-
 /**
  * Generates the 'signing message' form of a transaction. It derives the type of transaction and
  * applies the appropriate domain separator based on if there is extra data such as a fee payer or

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -9,7 +9,13 @@
 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,
+  Secp256k1PublicKey,
+  Secp256k1Signature,
+} from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { getInfo } from "../../internal/account";
 import { getLedgerInfo } from "../../internal/general";
@@ -216,7 +222,11 @@ export function generateViewFunctionPayloadWithABI(args: InputViewFunctionDataWi
 
 function generateTransactionPayloadScript(args: InputScriptData) {
   return new TransactionPayloadScript(
-    new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), args.typeArguments ?? [], args.functionArguments),
+    new Script(
+      Hex.fromHexInput(args.bytecode).toUint8Array(),
+      standardizeTypeTags(args.typeArguments),
+      args.functionArguments,
+    ),
   );
 }
 
@@ -441,6 +451,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) {
@@ -449,6 +464,11 @@ 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) {
+      // TODO: Replace with the line below one simulation works properly for Keyless
+      // return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(KeylessSignature.getSimulationSignature()));
+      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));
+    }
   }
 
   // legacy code