@aptos-labs/ts-sdk 1.17.0-zeta.0 → 1.17.0

package/src/core/crypto/poseidon.ts

@@ -1,144 +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 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

@@ -1,16 +0,0 @@
-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/internal/keyless.ts

@@ -1,121 +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/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, 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";
-
-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, uidKey = "sub" } = args;
-  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 { 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 });
-  // 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;
-
-  const keylessAccount = KeylessAccount.create({ ...args, proof, pepper, proofFetchCallback });
-
-  return keylessAccount;
-}

package/src/types/keyless.ts

@@ -1,42 +0,0 @@
-export type ProverRequest = {
-  jwt_b64: string;
-  epk: string;
-  exp_date_secs: number;
-  exp_horizon_secs: number;
-  epk_blinder: string;
-  uid_key: string;
-  pepper: string;
-};
-export type ProverResponse = {
-  proof: { a: string; b: string; c: string };
-  public_inputs_hash: string;
-  training_wheels_signature: string;
-};
-export type PepperFetchRequest = {
-  jwt_b64: number;
-  epk: string;
-  exp_date_secs: number;
-  epk_blinder: string;
-  uid_key: string;
-  derivation_path: string;
-};
-export type PepperFetchResponse = { signature: string; pepper: string; address: string };
-
-export type KeylessConfigurationResponse = {
-  max_commited_epk_bytes: number;
-  max_exp_horizon_secs: string;
-  max_extra_field_bytes: number;
-  max_iss_val_bytes: number;
-  max_jwt_header_b64_bytes: number;
-  max_signatures_per_txn: number;
-  override_aud_vals: string[];
-  training_wheels_pubkey: { vec: string[] };
-};
-
-export type Groth16VerificationKeyResponse = {
-  alpha_g1: string;
-  beta_g2: string;
-  delta_g2: string;
-  gamma_abc_g1: [string, string];
-  gamma_g2: string;
-};