@aptos-labs/ts-sdk 1.16.0-zeta.0 → 1.16.0-zeta.2

package/src/core/crypto/keyless.ts

@@ -7,9 +7,11 @@ import { Deserializer, Serializable, Serializer } from "../../bcs";
 import { Hex } from "../hex";
 import { HexInput, EphemeralCertificateVariant, AnyPublicKeyVariant, SigningScheme, ZkpVariant } from "../../types";
 import { EphemeralPublicKey, EphemeralSignature } from "./ephemeral";
-import { bigIntToBytesLE, bytesToBigIntLE, hashASCIIStrToField, poseidonHash } from "./poseidon";
+import { bigIntToBytesLE, bytesToBigIntLE, hashStrToField, poseidonHash } from "./poseidon";
 import { AuthenticationKey } from "../authenticationKey";
 import { Proof } from "./proof";
+import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
+import { Groth16VerificationKeyResponse } from "../../types/keyless";
 
 export const EPK_HORIZON_SECS = 10000000;
 export const MAX_AUD_VAL_BYTES = 120;
@@ -28,15 +30,23 @@ export const MAX_COMMITED_EPK_BYTES = 93;
 export class KeylessPublicKey extends AccountPublicKey {
   static readonly ID_COMMITMENT_LENGTH: number = 32;
 
+  /**
+   * The value of the 'iss' claim on the JWT which identifies the OIDC provider.
+   */
   readonly iss: string;
 
+  /**
+   * A value representing a cryptographic commitment to a user identity.
+   *
+   * It is calculated from the aud, uidKey, uidVal, pepper.
+   */
   readonly idCommitment: Uint8Array;
 
   constructor(iss: string, idCommitment: HexInput) {
     super();
     const idcBytes = Hex.fromHexInput(idCommitment).toUint8Array();
     if (idcBytes.length !== KeylessPublicKey.ID_COMMITMENT_LENGTH) {
-      throw new Error(`Address seed length in bytes should be ${KeylessPublicKey.ID_COMMITMENT_LENGTH}`);
+      throw new Error(`Id Commitment length in bytes should be ${KeylessPublicKey.ID_COMMITMENT_LENGTH}`);
     }
     this.iss = iss;
     this.idCommitment = idcBytes;
@@ -135,9 +145,9 @@ function computeIdCommitment(args: { uidKey: string; uidVal: string; aud: string
 
   const fields = [
     bytesToBigIntLE(Hex.fromHexInput(pepper).toUint8Array()),
-    hashASCIIStrToField(aud, MAX_AUD_VAL_BYTES),
-    hashASCIIStrToField(uidVal, MAX_UID_VAL_BYTES),
-    hashASCIIStrToField(uidKey, MAX_UID_KEY_BYTES),
+    hashStrToField(aud, MAX_AUD_VAL_BYTES),
+    hashStrToField(uidVal, MAX_UID_VAL_BYTES),
+    hashStrToField(uidKey, MAX_UID_KEY_BYTES),
   ];
 
   return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ID_COMMITMENT_LENGTH);
@@ -160,7 +170,7 @@ export class KeylessSignature extends Signature {
   /**
    * The expiry timestamp in seconds of the EphemeralKeyPair used to sign
    */
-  readonly expiryDateSecs: bigint | number;
+  readonly expiryDateSecs: number;
 
   /**
    * The ephemeral public key used to verify the signature
@@ -175,7 +185,7 @@ export class KeylessSignature extends Signature {
   constructor(args: {
     jwtHeader: string;
     ephemeralCertificate: EphemeralCertificate;
-    expiryDateSecs: bigint | number;
+    expiryDateSecs: number;
     ephemeralPublicKey: EphemeralPublicKey;
     ephemeralSignature: EphemeralSignature;
   }) {
@@ -213,7 +223,7 @@ export class KeylessSignature extends Signature {
     const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
     return new KeylessSignature({
       jwtHeader,
-      expiryDateSecs,
+      expiryDateSecs: Number(expiryDateSecs),
       ephemeralCertificate,
       ephemeralPublicKey,
       ephemeralSignature,
@@ -228,13 +238,31 @@ export class KeylessSignature extends Signature {
     const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
     return new KeylessSignature({
       jwtHeader,
-      expiryDateSecs,
+      expiryDateSecs: Number(expiryDateSecs),
       ephemeralCertificate,
       ephemeralPublicKey,
       ephemeralSignature,
     });
   }
 
+  static getSimulationSignature(): KeylessSignature {
+    return new KeylessSignature({
+      jwtHeader: "{}",
+      ephemeralCertificate: new EphemeralCertificate(
+        new ZeroKnowledgeSig({
+          proof: new ZkProof(
+            new Groth16Zkp({ a: new Uint8Array(32), b: new Uint8Array(64), c: new Uint8Array(32) }),
+            ZkpVariant.Groth16,
+          ),
+        }),
+        EphemeralCertificateVariant.ZkProof,
+      ),
+      expiryDateSecs: 0,
+      ephemeralPublicKey: new EphemeralPublicKey(new Ed25519PublicKey(new Uint8Array(32))),
+      ephemeralSignature: new EphemeralSignature(new Ed25519Signature(new Uint8Array(64))),
+    });
+  }
+
   static isSignature(signature: Signature): signature is KeylessSignature {
     return signature instanceof KeylessSignature;
   }
@@ -282,6 +310,48 @@ export class EphemeralCertificate extends Signature {
   }
 }
 
+class G1Bytes extends Serializable {
+  data: Uint8Array;
+
+  constructor(data: HexInput) {
+    super();
+    this.data = Hex.fromHexInput(data).toUint8Array();
+    if (this.data.length !== 32) {
+      throw new Error("Input needs to be 32 bytes");
+    }
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeFixedBytes(this.data);
+  }
+
+  static deserialize(deserializer: Deserializer): G1Bytes {
+    const bytes = deserializer.deserializeFixedBytes(32);
+    return new G1Bytes(bytes);
+  }
+}
+
+class G2Bytes extends Serializable {
+  data: Uint8Array;
+
+  constructor(data: HexInput) {
+    super();
+    this.data = Hex.fromHexInput(data).toUint8Array();
+    if (this.data.length !== 64) {
+      throw new Error("Input needs to be 64 bytes");
+    }
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeFixedBytes(this.data);
+  }
+
+  static deserialize(deserializer: Deserializer): G2Bytes {
+    const bytes = deserializer.deserializeFixedBytes(64);
+    return new G2Bytes(bytes);
+  }
+}
+
 /**
  * A representation of a Groth16 proof.  The points are the compressed serialization of affine reprentation of the proof.
  */
@@ -289,36 +359,36 @@ export class Groth16Zkp extends Proof {
   /**
    * The bytes of G1 proof point a
    */
-  a: Uint8Array;
+  a: G1Bytes;
 
   /**
    * The bytes of G2 proof point b
    */
-  b: Uint8Array;
+  b: G2Bytes;
 
   /**
    * The bytes of G1 proof point c
    */
-  c: Uint8Array;
+  c: G1Bytes;
 
   constructor(args: { a: HexInput; b: HexInput; c: HexInput }) {
     super();
     const { a, b, c } = args;
-    this.a = Hex.fromHexInput(a).toUint8Array();
-    this.b = Hex.fromHexInput(b).toUint8Array();
-    this.c = Hex.fromHexInput(c).toUint8Array();
+    this.a = new G1Bytes(a);
+    this.b = new G2Bytes(b);
+    this.c = new G1Bytes(c);
   }
 
   serialize(serializer: Serializer): void {
-    serializer.serializeFixedBytes(this.a);
-    serializer.serializeFixedBytes(this.b);
-    serializer.serializeFixedBytes(this.c);
+    this.a.serialize(serializer);
+    this.b.serialize(serializer);
+    this.c.serialize(serializer);
   }
 
   static deserialize(deserializer: Deserializer): Groth16Zkp {
-    const a = deserializer.deserializeFixedBytes(32);
-    const b = deserializer.deserializeFixedBytes(64);
-    const c = deserializer.deserializeFixedBytes(32);
+    const a = G1Bytes.deserialize(deserializer).bcsToBytes();
+    const b = G2Bytes.deserialize(deserializer).bcsToBytes();
+    const c = G1Bytes.deserialize(deserializer).bcsToBytes();
     return new Groth16Zkp({ a, b, c });
   }
 }
@@ -371,12 +441,13 @@ export class ZeroKnowledgeSig extends Signature {
   readonly expHorizonSecs: bigint;
 
   /**
-   * A key value pair on the JWT token that can be made public
+   * A key value pair on the JWT token that can be specified on the signature which would reveal the value on chain.
+   * Can be used to assert identity or other attributes.
    */
   readonly extraField?: string;
 
   /**
-   * Set in the case of signing by recovery services
+   * The 'aud' value of the recovery service which is set when recovering an account.
    */
   readonly overrideAudVal?: string;
 
@@ -451,3 +522,64 @@ export class ZeroKnowledgeSig extends Signature {
     return new ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
   }
 }
+
+export class KeylessConfiguration {
+  readonly verficationKey: Groth16VerificationKey;
+
+  readonly maxExpHorizonSecs: number;
+
+  constructor(verficationKey: Groth16VerificationKey, maxExpHorizonSecs: number) {
+    this.verficationKey = verficationKey;
+    this.maxExpHorizonSecs = maxExpHorizonSecs;
+  }
+
+  static create(res: Groth16VerificationKeyResponse, maxExpHorizonSecs: number): KeylessConfiguration {
+    return new KeylessConfiguration(
+      new Groth16VerificationKey({
+        alphaG1: res.alpha_g1,
+        betaG2: res.beta_g2,
+        deltaG2: res.delta_g2,
+        gammaAbcG1: res.gamma_abc_g1,
+        gammaG2: res.gamma_g2,
+      }),
+      maxExpHorizonSecs,
+    );
+  }
+}
+
+class Groth16VerificationKey {
+  readonly alphaG1: G1Bytes;
+
+  readonly betaG2: G2Bytes;
+
+  readonly deltaG2: G2Bytes;
+
+  readonly gammaAbcG1: G1Bytes[];
+
+  readonly gammaG2: G2Bytes;
+
+  constructor(args: {
+    alphaG1: HexInput;
+    betaG2: HexInput;
+    deltaG2: HexInput;
+    gammaAbcG1: [HexInput, HexInput];
+    gammaG2: HexInput;
+  }) {
+    const { alphaG1, betaG2, deltaG2, gammaAbcG1, gammaG2 } = args;
+    this.alphaG1 = new G1Bytes(alphaG1);
+    this.betaG2 = new G2Bytes(betaG2);
+    this.deltaG2 = new G2Bytes(deltaG2);
+    this.gammaAbcG1 = [new G1Bytes(gammaAbcG1[0]), new G1Bytes(gammaAbcG1[1])];
+    this.gammaG2 = new G2Bytes(gammaG2);
+  }
+
+  static fromGroth16VerificationKeyResponse(res: Groth16VerificationKeyResponse): Groth16VerificationKey {
+    return new Groth16VerificationKey({
+      alphaG1: res.alpha_g1,
+      betaG2: res.beta_g2,
+      deltaG2: res.delta_g2,
+      gammaAbcG1: res.gamma_abc_g1,
+      gammaG2: res.gamma_g2,
+    });
+  }
+}

package/src/core/crypto/poseidon.ts

@@ -41,14 +41,18 @@ 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) {
+/**
+ * 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) {
+function hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint {
   if (bytes.length > maxSizeBytes) {
     throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
   }
@@ -123,11 +127,18 @@ function padUint8ArrayWithZeros(inputArray: Uint8Array, paddedSize: number): Uin
   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 {
-  const poseidonFixedHash = numInputsToPoseidonFunc[inputs.length - 1];
-
-  if (poseidonFixedHash) {
-    return poseidonFixedHash(inputs);
+  if (inputs.length > numInputsToPoseidonFunc.length) {
+    throw new Error(
+      `Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`,
+    );
   }
-  throw new Error(`Unable to hash input of length ${inputs.length}`);
+  return numInputsToPoseidonFunc[inputs.length - 1](inputs);
 }

package/src/internal/keyless.ts

@@ -5,14 +5,79 @@
  * 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.
+ * keyless namespace and without having a dependency cycle error.
  */
 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 { 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 { PepperFetchResponse, ProverResponse } from "../types/keyless";
+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;
@@ -26,12 +91,12 @@ export async function getPepper(args: {
   const body = {
     jwt_b64: jwt,
     epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
-    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
     epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
-    uid_key: uidKey,
+    uid_key: uidKey || "sub",
     derivation_path: derivationPath,
   };
-  const { data } = await postAptosPepperService<any, PepperFetchResponse>({
+  const { data } = await postAptosPepperService<PepperFetchRequest, PepperFetchResponse>({
     aptosConfig,
     path: "fetch",
     body,
@@ -47,21 +112,21 @@ export async function getProof(args: {
   ephemeralKeyPair: EphemeralKeyPair;
   pepper: HexInput;
   uidKey?: string;
-  extraFieldKey?: string;
 }): Promise<ZeroKnowledgeSig> {
-  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;
+  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: Number(ephemeralKeyPair.expiryDateSecs),
+    exp_date_secs: 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>({
+  console.log(JSON.stringify(json))
+
+  const { data } = await postAptosProvingService<ProverRequest, ProverResponse>({
     aptosConfig,
     path: "prove",
     body: json,
@@ -89,14 +154,17 @@ export async function deriveKeylessAccount(args: {
   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) {
+  } else {
+    pepper = Hex.fromHexInput(pepper).toUint8Array();
+  }
+
+  if (pepper.length !== KeylessAccount.PEPPER_LENGTH) {
     throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);
   }
 

package/src/internal/transactionSubmission.ts

@@ -7,8 +7,8 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveVector, U8 } from "../bcs";
-import { AptosApiError, postAptosFullNode } from "../client";
-import { Account, KeylessAccount, KeylessError, MultiKeyAccount } from "../account";
+import { postAptosFullNode } from "../client";
+import { Account, KeylessAccount, MultiKeyAccount } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { PrivateKey } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";

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 { CryptoHashable } from "../../bcs/cryptoHasher";
 
 /**
  * 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 hashable An object that has a bcs serialized form
- *
- * @returns The Uint8Array of the signing message
- */
-export function generateSigningMessageForBcsCryptoHashable(hashable: CryptoHashable): Uint8Array {
-  return generateSigningMessage(hashable.bcsToBytes(), hashable.domainSeparator);
-}
-
 /**
  * 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

@@ -450,9 +450,9 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
   return new SignedTransaction(transaction.rawTransaction, transactionAuthenticator).bcsToBytes();
 }
 
-export function getAuthenticatorForSimulation(pk: PublicKey) {
-  let publicKey = pk;
+export function getAuthenticatorForSimulation(publicKey: PublicKey) {
   if (publicKey instanceof KeylessPublicKey || publicKey instanceof Secp256k1PublicKey) {
+    // eslint-disable-next-line no-param-reassign
     publicKey = new AnyPublicKey(publicKey);
   }
 
@@ -465,6 +465,8 @@ export function getAuthenticatorForSimulation(pk: PublicKey) {
       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))));
     }
   }

package/src/types/index.ts

@@ -322,9 +322,9 @@ export type GasEstimation = {
   prioritized_gas_estimate?: number;
 };
 
-export type MoveResource = {
+export type MoveResource<T = {}> = {
   type: MoveStructId;
-  data: {};
+  data: T;
 };
 
 export type AccountData = {

package/src/types/keyless.ts

@@ -1,6 +1,42 @@
+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;
+};

package/src/utils/apiEndpoints.ts

@@ -26,14 +26,16 @@ export const NetworkToPepperAPI: Record<string, string> = {
   mainnet: "https://api.mainnet.aptoslabs.com/keyless/pepper/v0",
   testnet: "https://api.testnet.aptoslabs.com/keyless/pepper/v0",
   devnet: "https://api.devnet.aptoslabs.com/keyless/pepper/v0",
-  local: "http://127.0.0.1:8000/v0",
+  // Use the devnet service for local environment
+  local: "https://api.devnet.aptoslabs.com/keyless/pepper/v0",
 };
 
 export const NetworkToProverAPI: Record<string, string> = {
   mainnet: "https://api.mainnet.aptoslabs.com/keyless/prover/v0",
   testnet: "https://api.testnet.aptoslabs.com/keyless/prover/v0",
-  devnet: "https://api.devnet.aptoslabs.com/keyless/prover/v0",
-  local: "http://127.0.0.1:8083/v0",
+  devnet: "https://prover.keyless.devnet.aptoslabs.com/v0",
+  // Use the devnet service for local environment
+  local: "https://api.devnet.aptoslabs.com/keyless/prover/v0",
 };
 
 export enum Network {

package/src/utils/helpers.ts

@@ -13,7 +13,6 @@ export async function sleep(timeMs: number): Promise<null> {
   });
 }
 
-
 export function currentTimeInSeconds(): number {
   return Math.floor(new Date().getTime() / 1000);
 }

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "1.16.0-zeta.0";
+export const VERSION = "1.16.0-zeta.2";

package/dist/esm/bcs/cryptoHasher.d.mts

@@ -1,15 +0,0 @@
-import { Serializable } from './serializer.mjs';
-import '../core/hex.mjs';
-import '../core/common.mjs';
-import '../types/index.mjs';
-import '../utils/apiEndpoints.mjs';
-import '../types/indexer.mjs';
-import '../types/generated/operations.mjs';
-import '../types/generated/types.mjs';
-
-type AptsoDomainSeparator = `APTOS::${string}`;
-declare abstract class CryptoHashable extends Serializable {
-    abstract readonly domainSeparator: AptsoDomainSeparator;
-}
-
-export { type AptsoDomainSeparator, CryptoHashable };

package/dist/esm/bcs/cryptoHasher.mjs

@@ -1,2 +0,0 @@
-import{a}from"../chunk-KPZDC5ZE.mjs";import"../chunk-TVRJ3M7B.mjs";import"../chunk-AOCNYMMX.mjs";import"../chunk-FBPNHF54.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-FVA2OPG4.mjs";export{a as CryptoHashable};
-//# sourceMappingURL=cryptoHasher.mjs.map

package/dist/esm/chunk-5ADNWXP2.mjs

@@ -1,2 +0,0 @@
-import{poseidon1 as s,poseidon2 as h,poseidon3 as u,poseidon4 as g,poseidon5 as a,poseidon6 as d,poseidon7 as c,poseidon8 as p,poseidon9 as f,poseidon10 as l,poseidon11 as A,poseidon12 as U,poseidon13 as b,poseidon14 as I,poseidon15 as w,poseidon16 as E}from"poseidon-lite";var y=[s,h,u,g,a,d,c,p,f,l,A,U,b,I,w,E],i=31,B=16,e=(B-1)*i;function x(n,t){let o=new TextEncoder().encode(n);return m(o,t)}function m(n,t){if(n.length>t)throw new Error(`Inputted bytes of length ${n} is longer than ${t}`);let r=_(n,t);return k(r)}function T(n,t){if(n.length>t)throw new Error(`Input bytes of length ${n} is longer than ${t}`);let r=N(n,t);return $(r)}function _(n,t){if(n.length>t)throw new Error(`Input bytes of length ${n} is longer than ${t}`);return T(n,t).concat([BigInt(n.length)])}function $(n){if(n.length>e)throw new Error(`Can't pack more than ${e}.  Was given ${n.length} bytes`);return P(n,i).map(t=>L(t))}function P(n,t){let r=[];for(let o=0;o<n.length;o+=t)r.push(n.subarray(o,o+t));return r}function L(n){let t=BigInt(0);for(let r=n.length-1;r>=0;r-=1)t=t<<BigInt(8)|BigInt(n[r]);return t}function M(n,t){let r=new Uint8Array(t);for(let o=0;o<t;o+=1)r[o]=Number(n&BigInt(255)),n>>=BigInt(8);return r}function N(n,t){if(t<n.length)throw new Error("Padded size must be greater than or equal to the input array size.");let r=new Uint8Array(t);r.set(n);for(let o=n.length;o<t;o+=1)r[o]=0;return r}function k(n){let t=y[n.length-1];if(t)return t(n);throw new Error(`Unable to hash input of length ${n.length}`)}export{x as a,_ as b,L as c,M as d,k as e};
-//# sourceMappingURL=chunk-5ADNWXP2.mjs.map