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

package/src/bcs/deserializer.ts

@@ -77,16 +77,22 @@ export class Deserializer {
   }
 
   /**
-   * Deserializes a an optional string.
+   * Deserializes a an optional deserializable class.
    *
-   * BCS layout for Optional<String>: 0 if none, else 1 | string_length | string_content
-   * @example
-   * ```ts
-   * const deserializer = new Deserializer(new Uint8Array([0x00]));
-   * assert(deserializer.deserializeOptionStr() === undefined);
-   * const deserializer = new Deserializer(new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
-   * assert(deserializer.deserializeOptionStr() === "1234abcd");
-   * ```
+   * BCS layout for Optional<T>: 0 if none, else 1 | bcs representation of class
+   * 
+   * @example 
+   * const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
+   * const value = deserializer.deserializeOption(MyClass); // where MyClass has a `deserialize` function
+   * // value is now an instance of MyClass
+   * 
+   * const deserializer = new Deserializer(new Uint8Array([0]));
+   * const value = deserializer.deserializeOption(MyClass); // where MyClass has a `deserialize` function
+   * // value is undefined
+   * 
+   * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
+   *
+   * @returns the deserialized value of class type T
    */
   deserializeOption<T>(cls: Deserializable<T>): T | undefined {
     const exists = this.deserializeUleb128AsU32();

package/src/bcs/serializer.ts

@@ -317,6 +317,24 @@ export class Serializer {
     });
   }
 
+  /**
+   * Serializes a BCS Serializable values into a serializer instance or undefined.
+   * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
+   *
+   * @param values The array of BCS Serializable values
+   * 
+   * @example
+   * ```ts
+   * const serializer = new Serializer();
+   * serializer.serializeOption(new AccountAddress(...));
+   * const serializedBytes = serializer.toUint8Array();
+   * // serializedBytes is now the BCS-serialized byte representation of AccountAddress
+   * 
+   * const serializer = new Serializer();
+   * serializer.serializeOption(undefined);
+   * assert(serializer.toUint8Array() === new Uint8Array([0x00]));
+   * ```
+   */
   serializeOption<T extends Serializable>(value?: T): void {
     if (value === undefined) {
       this.serializeU32AsUleb128(0);
@@ -326,6 +344,28 @@ export class Serializer {
     }
   }
 
+  /**
+   * Serializes an optional string. UTF8 string is supported.
+   *
+   * The existence of the string is encoded first, 0 if undefined and 1 if it exists.
+   * Them the number of bytes in the string content is serialized, as a uleb128-encoded u32 integer.
+   * Then the string content is serialized as UTF8 encoded bytes.
+   *
+   * BCS layout for optional "string": 1 | string_length | string_content
+   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
+   *
+   * BCS layout for undefined: 0
+   * @example
+   * ```ts
+   * const serializer = new Serializer();
+   * serializer.serializeOptionStr("1234abcd");
+   * assert(serializer.toUint8Array() === new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
+   *
+   * const serializer = new Serializer();
+   * serializer.serializeOptionStr(undefined);
+   * assert(serializer.toUint8Array() === new Uint8Array([0]));
+   * ```
+   */
   serializeOptionStr(value?: string): void {
     if (value === undefined) {
       this.serializeU32AsUleb128(0);

package/src/client/core.ts

@@ -100,19 +100,16 @@ export async function aptosRequest<Req extends {}, Res extends {}>(
       );
     }
     result.data = indexerResponse.data as Res;
+  } else if (apiType === AptosApiType.PEPPER || apiType === AptosApiType.PROVER) {
+    if (result.status >= 500) {
+      throw new AptosApiError(options, result, `${response.data}`);
+    }
   }
 
   if (result.status >= 200 && result.status < 300) {
     return result;
   }
 
-  if (result.status >= 500) {
-    throw new AptosApiError(options, result, `${response.data}`);
-  }
-
-  if (aptosConfig.isPepperServiceRequest(url) || aptosConfig.isProverServiceRequest(url)) {
-    throw new AptosApiError(options, result, `${response.data}`);
-  }
 
   let errorMessage: string;
 

package/src/client/get.ts

@@ -89,6 +89,12 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
+/**
+ * Makes a get request to the pepper service
+ *
+ * @param options GetAptosRequestOptions
+ * @returns AptosResponse
+ */
 export async function getAptosPepperService<Req extends {}, Res extends {}>(
   options: GetAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {

package/src/client/post.ts

@@ -136,6 +136,12 @@ export async function postAptosFaucet<Req extends {}, Res extends {}>(
   });
 }
 
+/**
+ * Makes a post request to the pepper service
+ *
+ * @param options GetAptosRequestOptions
+ * @returns AptosResponse
+ */
 export async function postAptosPepperService<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {

package/src/core/crypto/cryptoHasher.ts

@@ -0,0 +1,16 @@
+import { generateSigningMessage } from "../../transactions/transactionBuilder/signingMessage";
+import { Serializable } from "../../bcs/serializer";
+
+export type AptsoDomainSeparator = `APTOS::${string}`;
+export abstract class CryptoHashable extends Serializable {
+  abstract readonly domainSeparator: AptsoDomainSeparator;
+
+  /**
+   * Hashes the bcs serialized from of the class. This is the typescript corollary to the BCSCryptoHash macro in aptos-core.
+   * 
+   * @returns Uint8Array
+   */
+  hash(): Uint8Array {
+    return generateSigningMessage(this.bcsToBytes(), this.domainSeparator);
+  }
+}

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,68 @@ 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,16 @@ 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,19 @@ 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>({
+  const { data } = await postAptosProvingService<ProverRequest, ProverResponse>({
     aptosConfig,
     path: "prove",
     body: json,
@@ -89,14 +152,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/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