@aptos-labs/ts-sdk 1.13.0-zeta.1 → 1.13.1

package/src/core/crypto/poseidon.ts

@@ -1,134 +0,0 @@
-/* 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 an ASCII string to a field element
-export function hashASCIIStrToField(str: string, maxSizeBytes: number) {
-  const textEncoder = new TextEncoder();
-  const strBytes = textEncoder.encode(str);
-  return hashBytesWithLen(strBytes, maxSizeBytes);
-}
-
-function hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number) {
-  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;
-}
-
-// From chatGPT
-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;
-}
-
-export function poseidonHash(inputs: (number | bigint | string)[]): bigint {
-  const poseidonFixedHash = numInputsToPoseidonFunc[inputs.length - 1];
-
-  if (poseidonFixedHash) {
-    return poseidonFixedHash(inputs);
-  }
-  throw new Error(`Unable to hash input of length ${inputs.length}`);
-}

package/src/internal/keyless.ts

@@ -1,205 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * This file contains the underlying implementations for exposed API surface in
- * the {@link api/oidb}. By moving the methods out into a separate file,
- * other namespaces and processes can access these methods without depending on the entire
- * faucet namespace and without having a dependency cycle error.
- */
-import { jwtDecode } from "jwt-decode";
-import { bls12_381 as bls } from "@noble/curves/bls12-381";
-import { ProjPointType } from "@noble/curves/abstract/weierstrass";
-import { AptosConfig } from "../api/aptosConfig";
-import { getAptosPepperService, postAptosPepperService, postAptosProvingService } from "../client";
-import {
-  APTOS_BIP44_DEFAULT_DERIVATION_PATH,
-  EPK_HORIZON_SECS,
-  EphemeralSignature,
-  Groth16Zkp,
-  Hex,
-  MultiKey,
-  SignedGroth16Signature,
-} from "../core";
-import { HexInput } from "../types";
-import { Serializer } from "../bcs";
-import { EphemeralKeyPair, KeylessAccount, MultiKeyAccount } from "../account";
-import { PepperFetchResponse, ProverResponse } from "../types/keyless";
-
-const APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST = "APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST";
-
-function stringToUint8Array(str: string): Uint8Array {
-  const encoder = new TextEncoder();
-  return encoder.encode(str);
-}
-
-const PINKAS_VUF_SECRET_KEY_BASE_AFFINE = bls.G2.hashToCurve(
-  stringToUint8Array("APTOS_KEYLESS_PEPPER_PINKAS_VUF_SECRET_KEY_BASE"),
-  { DST: APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST },
-).toAffine();
-
-function getPepperInput(args: { jwt: string; uidKey?: string }): ProjPointType<bigint> {
-  const { jwt, uidKey } = args;
-  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);
-  const serializer = new Serializer();
-  serializer.serializeStr(jwtPayload.iss);
-  serializer.serializeStr(jwtPayload.aud);
-  serializer.serializeStr(jwtPayload[uidKey || "sub"]);
-  serializer.serializeStr(uidKey || "sub");
-  const serial = serializer.toUint8Array();
-  const msg = bls.G1.hashToCurve(serial, { DST: "APTOS_PEPPER_SERVICE_BLS12381_VUF_DST" }).toAffine();
-  const pp = bls.G1.ProjectivePoint.fromAffine(msg);
-  return pp;
-}
-
-async function verifyPepperBase(args: {
-  aptosConfig: AptosConfig;
-  pepperInput: ProjPointType<bigint>;
-  pepperBase: Uint8Array;
-}): Promise<boolean> {
-  const { aptosConfig, pepperInput, pepperBase } = args;
-  const { data: pubKeyResponse } = await getAptosPepperService<any, { vrf_public_key_hex_string: string }>({
-    aptosConfig,
-    path: "vrf-pub-key",
-    originMethod: "getPepper",
-  });
-  const publicKeyFromService = bls.G2.ProjectivePoint.fromHex(pubKeyResponse.vrf_public_key_hex_string);
-  return bls.verifyShortSignature(pepperBase, pepperInput, publicKeyFromService);
-}
-
-export async function getPepper(args: {
-  aptosConfig: AptosConfig;
-  jwt: string;
-  ephemeralKeyPair: EphemeralKeyPair;
-  uidKey?: string;
-  derivationPath?: string;
-  verify?: boolean;
-}): Promise<Uint8Array> {
-  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, verify } = args;
-  let { derivationPath } = args;
-
-  const body = {
-    jwt_b64: jwt,
-    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),
-    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
-    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
-    uid_key: uidKey,
-  };
-  // console.log(JSON.stringify(body));
-  const { data } = await postAptosPepperService<any, PepperFetchResponse>({
-    aptosConfig,
-    path: "fetch",
-    body,
-    originMethod: "getPepper",
-    overrides: { WITH_CREDENTIALS: false },
-  });
-  const pepperBase = Hex.fromHexInput(data.signature).toUint8Array();
-
-  if (verify) {
-    const pepperVerified = verifyPepperBase({ aptosConfig, pepperBase, pepperInput: getPepperInput(args) });
-    if (!pepperVerified) {
-      throw new Error("Unable to verify");
-    }
-  }
-  // This takes the BLS VUF H(m)^sk and transforms it into a Pinkas VUF e(H(m), g_3^sk), where g_3 is the base of the secret key (computed pseudo-randomly via hash-to-curve).
-  // This gives us the freedom of either decentralizing the pepper service as a BLS-based MPC or on top of the validators, by reusing the Pinkas WVUF-based randomness infrastructure.
-  const newPepperBase = bls.pairing(
-    bls.G1.ProjectivePoint.fromHex(pepperBase),
-    bls.G2.ProjectivePoint.fromAffine(PINKAS_VUF_SECRET_KEY_BASE_AFFINE),
-  );
-
-  if (derivationPath === undefined) {
-    derivationPath = APTOS_BIP44_DEFAULT_DERIVATION_PATH;
-  }
-  const pepper = KeylessAccount.fromDerivationPath(derivationPath, bls.fields.Fp12.toBytes(newPepperBase));
-  return pepper.slice(0, 31);
-}
-
-export async function getProof(args: {
-  aptosConfig: AptosConfig;
-  jwt: string;
-  ephemeralKeyPair: EphemeralKeyPair;
-  pepper: HexInput;
-  uidKey?: string;
-  extraFieldKey?: string;
-}): Promise<SignedGroth16Signature> {
-  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;
-  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);
-  let extraField;
-  if (extraFieldKey) {
-    const extraFieldVal = jwtPayload[extraFieldKey];
-    extraField = `"${extraFieldKey}":"${extraFieldVal}",`;
-  }
-  const json = {
-    jwt_b64: jwt,
-    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),
-    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
-    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
-    exp_horizon_secs: EPK_HORIZON_SECS,
-    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
-    extra_field: extraFieldKey,
-    uid_key: uidKey || "sub",
-  };
-
-  const { data } = await postAptosProvingService<any, ProverResponse>({
-    aptosConfig,
-    path: "prove",
-    body: json,
-    originMethod: "getProof",
-    overrides: { WITH_CREDENTIALS: false },
-  });
-
-  const proofPoints = data.proof;
-  const proof = new Groth16Zkp({
-    a: proofPoints.a,
-    b: proofPoints.b,
-    c: proofPoints.c,
-  });
-
-  const signedProof = new SignedGroth16Signature({
-    proof,
-    extraField,
-    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),
-  });
-  return signedProof;
-}
-
-export async function deriveKeylessAccount(args: {
-  aptosConfig: AptosConfig;
-  jwt: string;
-  ephemeralKeyPair: EphemeralKeyPair;
-  uidKey?: string;
-  pepper?: HexInput;
-  extraFieldKey?: string;
-  disableConnect?: boolean;
-  fetchProofAsync?: boolean;
-}): Promise<KeylessAccount | MultiKeyAccount> {
-  const { fetchProofAsync } = args;
-  let { pepper, disableConnect } = args;
-
-  if (pepper || disableConnect) {
-    disableConnect = true;
-  }
-  if (pepper === undefined) {
-    pepper = await getPepper(args);
-  } else if (Hex.fromHexInput(pepper).toUint8Array().length !== 31) {
-    throw new Error("Pepper needs to be 31 bytes");
-  }
-
-  const proofPromise = getProof({ ...args, pepper });
-  const proof = fetchProofAsync ? proofPromise : await proofPromise;
-
-  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proofFetcherOrData: proof, pepper });
-
-  if (disableConnect === true) {
-    return keylessAccount;
-  }
-
-  const aptosConnectPublicKey = keylessAccount.deriveAptosConnectPublicKey();
-
-  const multiKey = new MultiKey({
-    publicKeys: [keylessAccount.publicKey, aptosConnectPublicKey],
-    signaturesRequired: 1,
-  });
-  return new MultiKeyAccount({ multiKey, signers: [keylessAccount] });
-}

package/src/transactions/transactionBuilder/signingMessage.ts

@@ -1,75 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * This file handles the transaction creation lifecycle.
- * It holds different operations to generate a transaction payload, a raw transaction,
- * and a signed transaction that can be simulated, signed and submitted to chain.
- */
-import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
-import {
-  RAW_TRANSACTION_SALT,
-  RAW_TRANSACTION_WITH_DATA_SALT,
-} from "../../utils/const";
-import {
-  FeePayerRawTransaction,
-  MultiAgentRawTransaction,
-  RawTransaction,
-} from "../instances";
-import {
-  AnyRawTransaction, AnyRawTransactionInstance,
-} from "../types";
-import { Serializable } from "../../bcs";
-
-/**
- * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
- *
- * @param transaction A aptos transaction type
- *
- * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
- */
-export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {
-  if (transaction.feePayerAddress) {
-    return new FeePayerRawTransaction(
-      transaction.rawTransaction,
-      transaction.secondarySignerAddresses ?? [],
-      transaction.feePayerAddress,
-    );
-  }
-  if (transaction.secondarySignerAddresses) {
-    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);
-  }
-
-  return transaction.rawTransaction;
-}
-
-export function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array {
-  const hash = sha3Hash.create();
-
-  hash.update(`APTOS::${domainSeparator}`);
-  
-  const prefix = hash.digest();
-
-  const body = bytes;
-
-  const mergedArray = new Uint8Array(prefix.length + body.length);
-  mergedArray.set(prefix);
-  mergedArray.set(body, prefix.length);
-
-  return mergedArray;
-}
-
-export function generateSigningMessageForSerializable(obj: Serializable): Uint8Array {
-  return generateSigningMessage(obj.bcsToBytes(), obj.constructor.name);
-}
-
-export function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array {
-  const rawTxn = deriveTransactionType(transaction);
-  if (rawTxn instanceof RawTransaction) {
-    return generateSigningMessage(rawTxn.bcsToBytes(),RAW_TRANSACTION_SALT);
-  } if (rawTxn instanceof MultiAgentRawTransaction || rawTxn instanceof FeePayerRawTransaction) {
-    return generateSigningMessage(rawTxn.bcsToBytes(),RAW_TRANSACTION_WITH_DATA_SALT);
-  }
-  throw new Error(`Unknown transaction type to sign on: ${rawTxn}`);
-}
-

package/src/types/keyless.ts

@@ -1,6 +0,0 @@
-export type ProverResponse = {
-  proof: { a: string; b: string; c: string };
-  public_inputs_hash: string;
-  training_wheels_signature: string;
-};
-export type PepperFetchResponse = { signature: string };