@aptos-labs/ts-sdk 1.14.0-zeta.3 → 1.15.0-win.0

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/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,119 +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
- * faucet namespace and without having a dependency cycle error.
- */
-import { jwtDecode } from "jwt-decode";
-import { AptosConfig } from "../api/aptosConfig";
-import { postAptosPepperService, postAptosProvingService } from "../client";
-import { EPK_HORIZON_SECS, EphemeralSignature, Groth16Zkp, Hex, ZeroKnowledgeSig, ZkProof } from "../core";
-import { HexInput, ZkpVariant } from "../types";
-import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
-import { PepperFetchResponse, ProverResponse } from "../types/keyless";
-
-export async function getPepper(args: {
-  aptosConfig: AptosConfig;
-  jwt: string;
-  ephemeralKeyPair: EphemeralKeyPair;
-  uidKey?: string;
-  derivationPath?: string;
-  verify?: boolean;
-}): Promise<Uint8Array> {
-  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, derivationPath } = args;
-
-  const body = {
-    jwt_b64: jwt,
-    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
-    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
-    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
-    uid_key: uidKey,
-    derivation_path: derivationPath,
-  };
-  const { data } = await postAptosPepperService<any, 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;
-  extraFieldKey?: string;
-}): Promise<ZeroKnowledgeSig> {
-  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;
-  const json = {
-    jwt_b64: jwt,
-    epk: ephemeralKeyPair.getPublicKey().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 groth16Zkp = new Groth16Zkp({
-    a: proofPoints.a,
-    b: proofPoints.b,
-    c: proofPoints.c,
-  });
-
-  let extraField;
-  if (extraFieldKey) {
-    const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);
-    const extraFieldVal = jwtPayload[extraFieldKey];
-    extraField = `"${extraFieldKey}":"${extraFieldVal}",`;
-  }
-
-  const signedProof = new ZeroKnowledgeSig({
-    proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),
-    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;
-  proofFetchCallback?: ProofFetchCallback;
-}): Promise<KeylessAccount> {
-  const { proofFetchCallback } = args;
-  let { pepper } = args;
-  if (pepper === undefined) {
-    pepper = await getPepper(args);
-  } else if (Hex.fromHexInput(pepper).toUint8Array().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/types/keyless.ts

@@ -1,37 +0,0 @@
-import { KeylessAccount } from "../account";
-import { AptosApiError } from "../client/types";
-
-export type ProverResponse = {
-  proof: { a: string; b: string; c: string };
-  public_inputs_hash: string;
-  training_wheels_signature: string;
-};
-export type PepperFetchResponse = { signature: string; pepper: string; address: string };
-
-export enum KeylessErrorType {
-  JWK_EXPIRED,
-  EPK_EXPIRED,
-  UNKNOWN_INVALID_SIGNATURE,
-  UNKNOWN,
-}
-export class KeylessError extends Error {
-  readonly type: KeylessErrorType;
-
-  private constructor(type: KeylessErrorType) {
-    super();
-    this.type = type;
-  }
-
-  static async fromAptosApiError(error: AptosApiError, signer: KeylessAccount): Promise<KeylessError> {
-    if (!error.data.message.includes("INVALID_SIGNATURE")) {
-      return new KeylessError(KeylessErrorType.UNKNOWN);
-    }
-    if (signer.isExpired()) {
-      return new KeylessError(KeylessErrorType.EPK_EXPIRED);
-    }
-    if (!(await signer.checkJwkValidity())) {
-      return new KeylessError(KeylessErrorType.JWK_EXPIRED);
-    }
-    return new KeylessError(KeylessErrorType.UNKNOWN_INVALID_SIGNATURE);
-  }
-}