@aptos-labs/ts-sdk 1.13.1-zeta.3 → 1.13.1-zeta.5

package/src/account/EphemeralKeyPair.ts

@@ -15,19 +15,19 @@ import { bytesToBigIntLE, padAndPackBytesWithLen, poseidonHash } from "../core/c
 import { EphemeralPublicKeyVariant, HexInput, SigningSchemeInput } from "../types";
 import { Deserializer, Serializable, Serializer } from "../bcs";
 
-export class EphemeralKeyPair extends Serializable{
+export class EphemeralKeyPair extends Serializable {
   readonly blinder: Uint8Array;
 
   readonly expiryDateSecs: bigint | number;
 
   readonly nonce: string;
 
-  readonly privateKey: PrivateKey;
+  private privateKey: PrivateKey;
 
-  readonly publicKey: EphemeralPublicKey;
+  private publicKey: EphemeralPublicKey;
 
   constructor(args: { privateKey: PrivateKey; expiryDateSecs?: bigint | number; blinder?: HexInput }) {
-    super()
+    super();
     const { privateKey, expiryDateSecs, blinder } = args;
     this.privateKey = privateKey;
     this.publicKey = new EphemeralPublicKey(privateKey.publicKey());
@@ -36,11 +36,15 @@ export class EphemeralKeyPair extends Serializable{
     this.nonce = this.generateNonce();
   }
 
+  getPublicKey(): EphemeralPublicKey {
+    return this.publicKey;
+  }
+
   serialize(serializer: Serializer): void {
     serializer.serializeU32AsUleb128(this.publicKey.variant);
-    serializer.serializeBytes(this.privateKey.toUint8Array())
-    serializer.serializeU64(this.expiryDateSecs)
-    serializer.serializeFixedBytes(this.blinder)
+    serializer.serializeBytes(this.privateKey.toUint8Array());
+    serializer.serializeU64(this.expiryDateSecs);
+    serializer.serializeFixedBytes(this.blinder);
   }
 
   static deserialize(deserializer: Deserializer): EphemeralKeyPair {
@@ -55,7 +59,11 @@ export class EphemeralKeyPair extends Serializable{
     }
     const expiryDateSecs = deserializer.deserializeU64();
     const blinder = deserializer.deserializeFixedBytes(31);
-    return new EphemeralKeyPair({privateKey, expiryDateSecs, blinder});
+    return new EphemeralKeyPair({ privateKey, expiryDateSecs, blinder });
+  }
+
+  static fromBytes(bytes: Uint8Array): EphemeralKeyPair {
+    return EphemeralKeyPair.deserialize(new Deserializer(bytes));
   }
 
   static generate(args?: { scheme: SigningSchemeInput }): EphemeralKeyPair {

package/src/account/KeylessAccount.ts

@@ -58,7 +58,7 @@ export class KeylessAccount implements Account {
 
   accountAddress: AccountAddress;
 
-  proof: SignedGroth16Signature | Promise<SignedGroth16Signature>;
+  proof: SignedGroth16Signature;
 
   signingScheme: SigningScheme;
 
@@ -72,10 +72,10 @@ export class KeylessAccount implements Account {
     uidVal: string;
     aud: string;
     pepper: HexInput;
-    proofFetcherOrData: Promise<SignedGroth16Signature> | SignedGroth16Signature;
+    proof: SignedGroth16Signature;
     jwt: string;
   }) {
-    const { address, ephemeralKeyPair, iss, uidKey, uidVal, aud, pepper, proofFetcherOrData, jwt } = args;
+    const { address, ephemeralKeyPair, iss, uidKey, uidVal, aud, pepper, proof, jwt } = args;
     this.ephemeralKeyPair = ephemeralKeyPair;
     const addressSeed = computeAddressSeed(args);
     this.publicKey = new KeylessPublicKey(iss, addressSeed);
@@ -84,12 +84,7 @@ export class KeylessAccount implements Account {
     this.uidVal = uidVal;
     this.aud = aud;
     this.jwt = jwt;
-    if (proofFetcherOrData instanceof Promise) {
-      this.proof = proofFetcherOrData;
-      this.initialize(proofFetcherOrData);
-    } else {
-      this.proof = proofFetcherOrData;
-    }
+    this.proof = proof;
 
     this.signingScheme = SigningScheme.SingleKey;
     const pepperBytes = Hex.fromHexInput(pepper).toUint8Array();
@@ -99,13 +94,12 @@ export class KeylessAccount implements Account {
     this.pepper = pepperBytes;
   }
 
-  async serialize(serializer: Serializer): Promise<void> {
+  serialize(serializer: Serializer): void {
     serializer.serializeStr(this.jwt);
     serializer.serializeStr(this.uidKey);
     serializer.serializeFixedBytes(this.pepper);
     this.ephemeralKeyPair.serialize(serializer);
-    const proof = await this.proof;
-    proof.serialize(serializer);
+    this.proof.serialize(serializer);
   }
 
   static deserialize(deserializer: Deserializer): KeylessAccount {
@@ -115,7 +109,7 @@ export class KeylessAccount implements Account {
     const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
     const proof = SignedGroth16Signature.deserialize(deserializer);
     return KeylessAccount.fromJWTAndProof({
-      proofFetcherOrData: proof,
+      proof,
       pepper,
       uidKey,
       jwt,
@@ -123,25 +117,17 @@ export class KeylessAccount implements Account {
     });
   }
 
-  async bcsToBytes(): Promise<Uint8Array> {
+  bcsToBytes(): Uint8Array {
     const serializer = new Serializer();
-    await this.serialize(serializer);
+    this.serialize(serializer);
     return serializer.toUint8Array();
   }
 
-  async bcsToHex(): Promise<Hex> {
-    const bcsBytes = await this.bcsToBytes();
+  bcsToHex(): Hex {
+    const bcsBytes = this.bcsToBytes();
     return Hex.fromHexInput(bcsBytes);
   }
 
-  private async initialize(promise: Promise<SignedGroth16Signature>) {
-    try {
-      this.proof = await promise;
-    } catch (error) {
-      throw new Error("Failed to fetch proof");
-    }
-  }
-
   signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey {
     const raw = deriveTransactionType(transaction);
     const signature = new AnySignature(this.sign(raw.bcsToBytes()));
@@ -165,7 +151,7 @@ export class KeylessAccount implements Account {
       throw new Error("Failed to fetch proof.");
     }
     const jwtHeader = this.jwt.split(".")[0];
-    const ephemeralPublicKey = this.ephemeralKeyPair.publicKey;
+    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();
 
     const serializer = new Serializer();
     serializer.serializeFixedBytes(Hex.fromHexInput(data).toUint8Array());
@@ -199,7 +185,7 @@ export class KeylessAccount implements Account {
     });
 
     const { expiryDateSecs } = this.ephemeralKeyPair;
-    const ephemeralPublicKey = this.ephemeralKeyPair.publicKey;
+    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();
     const ephemeralSignature = this.ephemeralKeyPair.sign(data);
     return new KeylessSignature({
       jwtHeader,
@@ -220,13 +206,13 @@ export class KeylessAccount implements Account {
   }
 
   static fromJWTAndProof(args: {
-    proofFetcherOrData: Promise<SignedGroth16Signature> | SignedGroth16Signature;
+    proof: SignedGroth16Signature;
     jwt: string;
     ephemeralKeyPair: EphemeralKeyPair;
     pepper: HexInput;
     uidKey?: string;
   }): KeylessAccount {
-    const { proofFetcherOrData, jwt, ephemeralKeyPair, pepper } = args;
+    const { proof, jwt, ephemeralKeyPair, pepper } = args;
     const uidKey = args.uidKey ?? "sub";
 
     const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);
@@ -237,7 +223,7 @@ export class KeylessAccount implements Account {
     const aud = jwtPayload.aud!;
     const uidVal = jwtPayload[uidKey];
     return new KeylessAccount({
-      proofFetcherOrData,
+      proof,
       ephemeralKeyPair,
       iss,
       uidKey,

package/src/api/keyless.ts

@@ -28,7 +28,6 @@ export class Keyless {
     uidKey?: string;
     pepper?: HexInput;
     extraFieldKey?: string;
-    fetchProofAsync?: boolean;
   }): Promise<KeylessAccount> {
     return deriveKeylessAccount({ aptosConfig: this.config, ...args });
   }

package/src/internal/keyless.ts

@@ -79,7 +79,7 @@ export async function getPepper(args: {
 
   const body = {
     jwt_b64: jwt,
-    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
     exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
     epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
     uid_key: uidKey,
@@ -131,7 +131,7 @@ export async function getProof(args: {
   }
   const json = {
     jwt_b64: jwt,
-    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
     epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
     exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
     exp_horizon_secs: EPK_HORIZON_SECS,
@@ -170,20 +170,16 @@ export async function deriveKeylessAccount(args: {
   uidKey?: string;
   pepper?: HexInput;
   extraFieldKey?: string;
-  fetchProofAsync?: boolean;
 }): Promise<KeylessAccount> {
-  const { fetchProofAsync } = args;
   let { pepper } = args;
   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 proof = await getProof({ ...args, pepper });
 
-  const proofPromise = getProof({ ...args, pepper });
-  const proof = fetchProofAsync ? proofPromise : await proofPromise;
-
-  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proofFetcherOrData: proof, pepper });
+  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proof, pepper });
 
     return keylessAccount;
 }

package/src/version.ts

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

package/dist/esm/chunk-DDZGSI33.mjs

@@ -1,2 +0,0 @@
-var t="1.13.1-zeta.3";export{t as a};
-//# sourceMappingURL=chunk-DDZGSI33.mjs.map

package/dist/esm/chunk-GFW5KSAZ.mjs

@@ -1,2 +0,0 @@
-import{a as j}from"./chunk-U6XKW7OK.mjs";import{a as g,b as I}from"./chunk-6SIZZAWU.mjs";import{d as x}from"./chunk-22CDTJSF.mjs";import{a as E,b as T}from"./chunk-INS2SYOV.mjs";import{i as w,j as K,k as y,m as A,n as b,o as l}from"./chunk-4X4HJL3N.mjs";import{k as S}from"./chunk-S5HG2QUD.mjs";import{b as P}from"./chunk-T23OVRNF.mjs";import{b as h}from"./chunk-TVRJ3M7B.mjs";import{b as u}from"./chunk-AOCNYMMX.mjs";import{a as f}from"./chunk-6IFMQ5AS.mjs";import{jwtDecode as O}from"jwt-decode";import{decode as B}from"base-64";function F(D){let e=D.replace(/-/g,"+").replace(/_/g,"/"),r=e+"==".substring(0,(3-e.length%3)%3);return B(r)}var o=class o{constructor(e){let{address:r,ephemeralKeyPair:t,iss:n,uidKey:a,uidVal:i,aud:s,pepper:p,proofFetcherOrData:c,jwt:d}=e;this.ephemeralKeyPair=t;let z=K(e);this.publicKey=new w(n,z),this.accountAddress=r?P.from(r):this.publicKey.authKey().derivedAddress(),this.uidKey=a,this.uidVal=i,this.aud=s,this.jwt=d,c instanceof Promise?(this.proof=c,this.initialize(c)):this.proof=c,this.signingScheme=2;let m=u.fromHexInput(p).toUint8Array();if(m.length!==o.PEPPER_LENGTH)throw new Error(`Pepper length in bytes should be ${o.PEPPER_LENGTH}`);this.pepper=m}async serialize(e){e.serializeStr(this.jwt),e.serializeStr(this.uidKey),e.serializeFixedBytes(this.pepper),this.ephemeralKeyPair.serialize(e),(await this.proof).serialize(e)}static deserialize(e){let r=e.deserializeStr(),t=e.deserializeStr(),n=e.deserializeFixedBytes(31),a=j.deserialize(e),i=A.deserialize(e);return o.fromJWTAndProof({proofFetcherOrData:i,pepper:n,uidKey:t,jwt:r,ephemeralKeyPair:a})}async bcsToBytes(){let e=new h;return await this.serialize(e),e.toUint8Array()}async bcsToHex(){let e=await this.bcsToBytes();return u.fromHexInput(e)}async initialize(e){try{this.proof=await e}catch{throw new Error("Failed to fetch proof")}}signWithAuthenticator(e){let r=g(e),t=new T(this.sign(r.bcsToBytes())),n=new E(this.publicKey);return new x(n,t)}async waitForProofFetch(){this.proof instanceof Promise&&await this.proof}sign(e){let{expiryDateSecs:r}=this.ephemeralKeyPair,t=Math.floor(new Date().getTime()/1e3);if(r<t)throw new Error("Ephemeral key pair is expired.");if(this.proof instanceof Promise)throw new Error("Failed to fetch proof.");let n=this.jwt.split(".")[0],a=this.ephemeralKeyPair.publicKey,i=new h;i.serializeFixedBytes(u.fromHexInput(e).toUint8Array()),i.serializeOption(this.proof.proof);let s=I(i.toUint8Array(),"APTOS::TransactionAndProof"),p=this.ephemeralKeyPair.sign(s);return new l({jwtHeader:F(n),openIdSignatureOrZkProof:new y(this.proof),expiryDateSecs:r,ephemeralPublicKey:a,ephemeralSignature:p})}signTransaction(e){let r=g(e);return this.sign(r.bcsToBytes())}signWithOpenIdSignature(e){let[r,t,n]=this.jwt.split("."),a=new b({jwtSignature:n,jwtPayloadJson:t,uidKey:this.uidKey,epkBlinder:this.ephemeralKeyPair.blinder,pepper:this.pepper}),{expiryDateSecs:i}=this.ephemeralKeyPair,s=this.ephemeralKeyPair.publicKey,p=this.ephemeralKeyPair.sign(e);return new l({jwtHeader:r,openIdSignatureOrZkProof:new y(a),expiryDateSecs:i,ephemeralPublicKey:s,ephemeralSignature:p})}verifySignature(e){return!0}static fromBytes(e){return o.deserialize(new f(e))}static fromJWTAndProof(e){let{proofFetcherOrData:r,jwt:t,ephemeralKeyPair:n,pepper:a}=e,i=e.uidKey??"sub",s=O(t),p=s.iss;if(typeof s.aud!="string")throw new Error("aud was not found or an array of values");let c=s.aud,d=s[i];return new o({proofFetcherOrData:r,ephemeralKeyPair:n,iss:p,uidKey:i,uidVal:d,aud:c,pepper:a,jwt:t})}static fromDerivationPath(e,r){return S(e,o.SLIP_0010_SEED,r)}};o.PEPPER_LENGTH=31,o.SLIP_0010_SEED="32 bytes";var H=o;export{H as a};
-//# sourceMappingURL=chunk-GFW5KSAZ.mjs.map

package/dist/esm/chunk-GFW5KSAZ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/KeylessAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { JwtPayload, jwtDecode } from \"jwt-decode\";\nimport { decode } from \"base-64\";\nimport { HexInput, SigningScheme } from \"../types\";\nimport { AccountAddress } from \"../core/accountAddress\";\nimport {\n  AnyPublicKey,\n  AnySignature,\n  KeylessPublicKey,\n  KeylessSignature,\n  OpenIdSignature,\n  OpenIdSignatureOrZkProof,\n  Signature,\n  SignedGroth16Signature,\n  computeAddressSeed,\n  fromDerivationPath as fromDerivationPathInner,\n} from \"../core/crypto\";\n\nimport { Account } from \"./Account\";\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\nimport { Hex } from \"../core/hex\";\nimport { AccountAuthenticatorSingleKey } from \"../transactions/authenticator/account\";\nimport { Deserializer, Serializer } from \"../bcs\";\nimport { deriveTransactionType, generateSigningMessage } from \"../transactions/transactionBuilder/signingMessage\";\nimport { AnyRawTransaction } from \"../transactions/types\";\n\nfunction base64UrlDecode(base64Url: string): string {\n  // Replace base64url-specific characters\n  const base64 = base64Url.replace(/-/g, \"+\").replace(/_/g, \"/\");\n\n  // Pad the string with '=' characters if needed\n  const paddedBase64 = base64 + \"==\".substring(0, (3 - (base64.length % 3)) % 3);\n\n  // Decode the base64 string using the base-64 library\n  const decodedString = decode(paddedBase64);\n\n  return decodedString;\n}\n\nexport class KeylessAccount implements Account {\n  static readonly PEPPER_LENGTH: number = 31;\n\n  static readonly SLIP_0010_SEED: string = \"32 bytes\";\n\n  publicKey: KeylessPublicKey;\n\n  ephemeralKeyPair: EphemeralKeyPair;\n\n  uidKey: string;\n\n  uidVal: string;\n\n  aud: string;\n\n  pepper: Uint8Array;\n\n  accountAddress: AccountAddress;\n\n  proof: SignedGroth16Signature | Promise<SignedGroth16Signature>;\n\n  signingScheme: SigningScheme;\n\n  jwt: string;\n\n  constructor(args: {\n    address?: AccountAddress;\n    ephemeralKeyPair: EphemeralKeyPair;\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    proofFetcherOrData: Promise<SignedGroth16Signature> | SignedGroth16Signature;\n    jwt: string;\n  }) {\n    const { address, ephemeralKeyPair, iss, uidKey, uidVal, aud, pepper, proofFetcherOrData, jwt } = args;\n    this.ephemeralKeyPair = ephemeralKeyPair;\n    const addressSeed = computeAddressSeed(args);\n    this.publicKey = new KeylessPublicKey(iss, addressSeed);\n    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();\n    this.uidKey = uidKey;\n    this.uidVal = uidVal;\n    this.aud = aud;\n    this.jwt = jwt;\n    if (proofFetcherOrData instanceof Promise) {\n      this.proof = proofFetcherOrData;\n      this.initialize(proofFetcherOrData);\n    } else {\n      this.proof = proofFetcherOrData;\n    }\n\n    this.signingScheme = SigningScheme.SingleKey;\n    const pepperBytes = Hex.fromHexInput(pepper).toUint8Array();\n    if (pepperBytes.length !== KeylessAccount.PEPPER_LENGTH) {\n      throw new Error(`Pepper length in bytes should be ${KeylessAccount.PEPPER_LENGTH}`);\n    }\n    this.pepper = pepperBytes;\n  }\n\n  async serialize(serializer: Serializer): Promise<void> {\n    serializer.serializeStr(this.jwt);\n    serializer.serializeStr(this.uidKey);\n    serializer.serializeFixedBytes(this.pepper);\n    this.ephemeralKeyPair.serialize(serializer);\n    const proof = await this.proof;\n    proof.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): KeylessAccount {\n    const jwt = deserializer.deserializeStr();\n    const uidKey = deserializer.deserializeStr();\n    const pepper = deserializer.deserializeFixedBytes(31);\n    const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);\n    const proof = SignedGroth16Signature.deserialize(deserializer);\n    return KeylessAccount.fromJWTAndProof({\n      proofFetcherOrData: proof,\n      pepper,\n      uidKey,\n      jwt,\n      ephemeralKeyPair,\n    });\n  }\n\n  async bcsToBytes(): Promise<Uint8Array> {\n    const serializer = new Serializer();\n    await this.serialize(serializer);\n    return serializer.toUint8Array();\n  }\n\n  async bcsToHex(): Promise<Hex> {\n    const bcsBytes = await this.bcsToBytes();\n    return Hex.fromHexInput(bcsBytes);\n  }\n\n  private async initialize(promise: Promise<SignedGroth16Signature>) {\n    try {\n      this.proof = await promise;\n    } catch (error) {\n      throw new Error(\"Failed to fetch proof\");\n    }\n  }\n\n  signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey {\n    const raw = deriveTransactionType(transaction);\n    const signature = new AnySignature(this.sign(raw.bcsToBytes()));\n    const publicKey = new AnyPublicKey(this.publicKey);\n    return new AccountAuthenticatorSingleKey(publicKey, signature);\n  }\n\n  async waitForProofFetch() {\n    if (this.proof instanceof Promise) {\n      await this.proof;\n    }\n  }\n\n  sign(data: HexInput): Signature {\n    const { expiryDateSecs } = this.ephemeralKeyPair;\n    const currentTimeInSeconds = Math.floor(new Date().getTime() / 1000);\n    if (expiryDateSecs < currentTimeInSeconds) {\n      throw new Error(\"Ephemeral key pair is expired.\");\n    }\n    if (this.proof instanceof Promise) {\n      throw new Error(\"Failed to fetch proof.\");\n    }\n    const jwtHeader = this.jwt.split(\".\")[0];\n    const ephemeralPublicKey = this.ephemeralKeyPair.publicKey;\n\n    const serializer = new Serializer();\n    serializer.serializeFixedBytes(Hex.fromHexInput(data).toUint8Array());\n    serializer.serializeOption(this.proof.proof);\n    const signMess = generateSigningMessage(serializer.toUint8Array(), \"APTOS::TransactionAndProof\");\n\n    const ephemeralSignature = this.ephemeralKeyPair.sign(signMess);\n\n    return new KeylessSignature({\n      jwtHeader: base64UrlDecode(jwtHeader),\n      openIdSignatureOrZkProof: new OpenIdSignatureOrZkProof(this.proof),\n      expiryDateSecs,\n      ephemeralPublicKey,\n      ephemeralSignature,\n    });\n  }\n\n  signTransaction(transaction: AnyRawTransaction): Signature {\n    const raw = deriveTransactionType(transaction);\n    return this.sign(raw.bcsToBytes());\n  }\n\n  signWithOpenIdSignature(data: HexInput): Signature {\n    const [jwtHeader, jwtPayload, jwtSignature] = this.jwt.split(\".\");\n    const openIdSig = new OpenIdSignature({\n      jwtSignature,\n      jwtPayloadJson: jwtPayload,\n      uidKey: this.uidKey,\n      epkBlinder: this.ephemeralKeyPair.blinder,\n      pepper: this.pepper,\n    });\n\n    const { expiryDateSecs } = this.ephemeralKeyPair;\n    const ephemeralPublicKey = this.ephemeralKeyPair.publicKey;\n    const ephemeralSignature = this.ephemeralKeyPair.sign(data);\n    return new KeylessSignature({\n      jwtHeader,\n      openIdSignatureOrZkProof: new OpenIdSignatureOrZkProof(openIdSig),\n      expiryDateSecs,\n      ephemeralPublicKey,\n      ephemeralSignature,\n    });\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this\n  verifySignature(args: { message: HexInput; signature: Signature }): boolean {\n    return true;\n  }\n\n  static fromBytes(bytes: Uint8Array): KeylessAccount {\n    return KeylessAccount.deserialize(new Deserializer(bytes));\n  }\n\n  static fromJWTAndProof(args: {\n    proofFetcherOrData: Promise<SignedGroth16Signature> | SignedGroth16Signature;\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    pepper: HexInput;\n    uidKey?: string;\n  }): KeylessAccount {\n    const { proofFetcherOrData, jwt, ephemeralKeyPair, pepper } = args;\n    const uidKey = args.uidKey ?? \"sub\";\n\n    const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);\n    const iss = jwtPayload.iss!;\n    if (typeof jwtPayload.aud !== \"string\") {\n      throw new Error(\"aud was not found or an array of values\");\n    }\n    const aud = jwtPayload.aud!;\n    const uidVal = jwtPayload[uidKey];\n    return new KeylessAccount({\n      proofFetcherOrData,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n    });\n  }\n\n  static fromDerivationPath(path: string, seed: Uint8Array): Uint8Array {\n    return fromDerivationPathInner(path, KeylessAccount.SLIP_0010_SEED, seed);\n  }\n}\n"],"mappings":"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","names":["jwtDecode","decode","base64UrlDecode","base64Url","base64","paddedBase64","decode","_KeylessAccount","args","address","ephemeralKeyPair","iss","uidKey","uidVal","aud","pepper","proofFetcherOrData","jwt","addressSeed","computeAddressSeed","KeylessPublicKey","AccountAddress","pepperBytes","Hex","serializer","deserializer","EphemeralKeyPair","proof","SignedGroth16Signature","Serializer","bcsBytes","promise","transaction","raw","deriveTransactionType","signature","AnySignature","publicKey","AnyPublicKey","AccountAuthenticatorSingleKey","data","expiryDateSecs","currentTimeInSeconds","jwtHeader","ephemeralPublicKey","signMess","generateSigningMessage","ephemeralSignature","KeylessSignature","OpenIdSignatureOrZkProof","jwtPayload","jwtSignature","openIdSig","OpenIdSignature","bytes","Deserializer","jwtDecode","path","seed","fromDerivationPath","KeylessAccount"]}

package/dist/esm/chunk-U6XKW7OK.mjs

@@ -1,2 +0,0 @@
-import{a as h}from"./chunk-4X4HJL3N.mjs";import{b as p,c as u,e as d}from"./chunk-FLYEALDB.mjs";import{a as c,b as y}from"./chunk-CYIEYPXQ.mjs";import{b as s}from"./chunk-CQJ4WN7M.mjs";import{a as l}from"./chunk-TVRJ3M7B.mjs";import{b as o}from"./chunk-AOCNYMMX.mjs";import{randomBytes as K}from"@noble/hashes/utils";var m=class r extends l{constructor(e){super();let{privateKey:t,expiryDateSecs:n,blinder:a}=e;this.privateKey=t,this.publicKey=new c(t.publicKey()),this.expiryDateSecs=n||BigInt(f(S()+h)),this.blinder=a!==void 0?o.fromHexInput(a).toUint8Array():g(),this.nonce=this.generateNonce()}serialize(e){e.serializeU32AsUleb128(this.publicKey.variant),e.serializeBytes(this.privateKey.toUint8Array()),e.serializeU64(this.expiryDateSecs),e.serializeFixedBytes(this.blinder)}static deserialize(e){let t=e.deserializeUleb128AsU32(),n;switch(t){case 0:n=s.deserialize(e);break;default:throw new Error(`Unknown variant index for EphemeralPublicKey: ${t}`)}let a=e.deserializeU64(),b=e.deserializeFixedBytes(31);return new r({privateKey:n,expiryDateSecs:a,blinder:b})}static generate(e){let t;switch(e?.scheme){case 0:default:t=s.generate()}return new r({privateKey:t})}generateNonce(){let e=p(this.publicKey.bcsToBytes(),93);return e.push(BigInt(this.expiryDateSecs)),e.push(u(this.blinder)),d(e).toString()}sign(e){return new y(this.privateKey.sign(e))}};function g(){return K(31)}function S(){return Math.floor(new Date().getTime()/1e3)}function f(r){let i=new Date(r*1e3);return i.setMinutes(0),i.setSeconds(0),i.setMilliseconds(0),Math.floor(i.getTime()/1e3)}export{m as a};
-//# sourceMappingURL=chunk-U6XKW7OK.mjs.map

package/dist/esm/chunk-U6XKW7OK.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/EphemeralKeyPair.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomBytes } from \"@noble/hashes/utils\";\n\nimport {\n  EPK_HORIZON_SECS,\n  Ed25519PrivateKey,\n  EphemeralPublicKey,\n  EphemeralSignature,\n  PrivateKey,\n} from \"../core/crypto\";\nimport { Hex } from \"../core/hex\";\nimport { bytesToBigIntLE, padAndPackBytesWithLen, poseidonHash } from \"../core/crypto/poseidon\";\nimport { EphemeralPublicKeyVariant, HexInput, SigningSchemeInput } from \"../types\";\nimport { Deserializer, Serializable, Serializer } from \"../bcs\";\n\nexport class EphemeralKeyPair extends Serializable{\n  readonly blinder: Uint8Array;\n\n  readonly expiryDateSecs: bigint | number;\n\n  readonly nonce: string;\n\n  readonly privateKey: PrivateKey;\n\n  readonly publicKey: EphemeralPublicKey;\n\n  constructor(args: { privateKey: PrivateKey; expiryDateSecs?: bigint | number; blinder?: HexInput }) {\n    super()\n    const { privateKey, expiryDateSecs, blinder } = args;\n    this.privateKey = privateKey;\n    this.publicKey = new EphemeralPublicKey(privateKey.publicKey());\n    this.expiryDateSecs = expiryDateSecs || BigInt(floorToWholeHour(currentTimeInSeconds() + EPK_HORIZON_SECS));\n    this.blinder = blinder !== undefined ? Hex.fromHexInput(blinder).toUint8Array() : generateBlinder();\n    this.nonce = this.generateNonce();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(this.publicKey.variant);\n    serializer.serializeBytes(this.privateKey.toUint8Array())\n    serializer.serializeU64(this.expiryDateSecs)\n    serializer.serializeFixedBytes(this.blinder)\n  }\n\n  static deserialize(deserializer: Deserializer): EphemeralKeyPair {\n    const variantIndex = deserializer.deserializeUleb128AsU32();\n    let privateKey: PrivateKey;\n    switch (variantIndex) {\n      case EphemeralPublicKeyVariant.Ed25519:\n        privateKey = Ed25519PrivateKey.deserialize(deserializer);\n        break;\n      default:\n        throw new Error(`Unknown variant index for EphemeralPublicKey: ${variantIndex}`);\n    }\n    const expiryDateSecs = deserializer.deserializeU64();\n    const blinder = deserializer.deserializeFixedBytes(31);\n    return new EphemeralKeyPair({privateKey, expiryDateSecs, blinder});\n  }\n\n  static generate(args?: { scheme: SigningSchemeInput }): EphemeralKeyPair {\n    let privateKey: PrivateKey;\n\n    switch (args?.scheme) {\n      case SigningSchemeInput.Ed25519:\n      default:\n        privateKey = Ed25519PrivateKey.generate();\n    }\n\n    return new EphemeralKeyPair({ privateKey });\n  }\n\n  generateNonce(): string {\n    const fields = padAndPackBytesWithLen(this.publicKey.bcsToBytes(), 93);\n    fields.push(BigInt(this.expiryDateSecs));\n    fields.push(bytesToBigIntLE(this.blinder));\n    const nonceHash = poseidonHash(fields);\n    return nonceHash.toString();\n  }\n\n  /**\n   * Sign the given message with the private key.\n   *   *\n   * @param data in HexInput format\n   * @returns EphemeralSignature\n   */\n  sign(data: HexInput): EphemeralSignature {\n    return new EphemeralSignature(this.privateKey.sign(data));\n  }\n}\n\nfunction generateBlinder(): Uint8Array {\n  return randomBytes(31);\n}\n\nfunction currentTimeInSeconds(): number {\n  return Math.floor(new Date().getTime() / 1000);\n}\n\nfunction floorToWholeHour(timestampInSeconds: number): number {\n  const date = new Date(timestampInSeconds * 1000);\n  // Reset minutes and seconds to zero\n  date.setMinutes(0);\n  date.setSeconds(0);\n  date.setMilliseconds(0);\n  return Math.floor(date.getTime() / 1000);\n}\n"],"mappings":"2QAGA,OAAS,eAAAA,MAAmB,sBAcrB,IAAMC,EAAN,MAAMC,UAAyBC,CAAY,CAWhD,YAAYC,EAAwF,CAClG,MAAM,EACN,GAAM,CAAE,WAAAC,EAAY,eAAAC,EAAgB,QAAAC,CAAQ,EAAIH,EAChD,KAAK,WAAaC,EAClB,KAAK,UAAY,IAAIG,EAAmBH,EAAW,UAAU,CAAC,EAC9D,KAAK,eAAiBC,GAAkB,OAAOG,EAAiBC,EAAqB,EAAIC,CAAgB,CAAC,EAC1G,KAAK,QAAUJ,IAAY,OAAYK,EAAI,aAAaL,CAAO,EAAE,aAAa,EAAIM,EAAgB,EAClG,KAAK,MAAQ,KAAK,cAAc,CAClC,CAEA,UAAUC,EAA8B,CACtCA,EAAW,sBAAsB,KAAK,UAAU,OAAO,EACvDA,EAAW,eAAe,KAAK,WAAW,aAAa,CAAC,EACxDA,EAAW,aAAa,KAAK,cAAc,EAC3CA,EAAW,oBAAoB,KAAK,OAAO,CAC7C,CAEA,OAAO,YAAYC,EAA8C,CAC/D,IAAMC,EAAeD,EAAa,wBAAwB,EACtDV,EACJ,OAAQW,EAAc,CACpB,OACEX,EAAaY,EAAkB,YAAYF,CAAY,EACvD,MACF,QACE,MAAM,IAAI,MAAM,iDAAiDC,CAAY,EAAE,CACnF,CACA,IAAMV,EAAiBS,EAAa,eAAe,EAC7CR,EAAUQ,EAAa,sBAAsB,EAAE,EACrD,OAAO,IAAIb,EAAiB,CAAC,WAAAG,EAAY,eAAAC,EAAgB,QAAAC,CAAO,CAAC,CACnE,CAEA,OAAO,SAASH,EAAyD,CACvE,IAAIC,EAEJ,OAAQD,GAAM,OAAQ,CACpB,OACA,QACEC,EAAaY,EAAkB,SAAS,CAC5C,CAEA,OAAO,IAAIf,EAAiB,CAAE,WAAAG,CAAW,CAAC,CAC5C,CAEA,eAAwB,CACtB,IAAMa,EAASC,EAAuB,KAAK,UAAU,WAAW,EAAG,EAAE,EACrE,OAAAD,EAAO,KAAK,OAAO,KAAK,cAAc,CAAC,EACvCA,EAAO,KAAKE,EAAgB,KAAK,OAAO,CAAC,EACvBC,EAAaH,CAAM,EACpB,SAAS,CAC5B,CAQA,KAAKI,EAAoC,CACvC,OAAO,IAAIC,EAAmB,KAAK,WAAW,KAAKD,CAAI,CAAC,CAC1D,CACF,EAEA,SAAST,GAA8B,CACrC,OAAOW,EAAY,EAAE,CACvB,CAEA,SAASd,GAA+B,CACtC,OAAO,KAAK,MAAM,IAAI,KAAK,EAAE,QAAQ,EAAI,GAAI,CAC/C,CAEA,SAASD,EAAiBgB,EAAoC,CAC5D,IAAMC,EAAO,IAAI,KAAKD,EAAqB,GAAI,EAE/C,OAAAC,EAAK,WAAW,CAAC,EACjBA,EAAK,WAAW,CAAC,EACjBA,EAAK,gBAAgB,CAAC,EACf,KAAK,MAAMA,EAAK,QAAQ,EAAI,GAAI,CACzC","names":["randomBytes","EphemeralKeyPair","_EphemeralKeyPair","Serializable","args","privateKey","expiryDateSecs","blinder","EphemeralPublicKey","floorToWholeHour","currentTimeInSeconds","EPK_HORIZON_SECS","Hex","generateBlinder","serializer","deserializer","variantIndex","Ed25519PrivateKey","fields","padAndPackBytesWithLen","bytesToBigIntLE","poseidonHash","data","EphemeralSignature","randomBytes","timestampInSeconds","date"]}

package/dist/esm/chunk-US26M7LP.mjs

@@ -1,2 +0,0 @@
-import{a as r,c as o}from"./chunk-WP7YNQOI.mjs";var t=class{constructor(e){this.config=e}async getPepper(e){return r({aptosConfig:this.config,...e})}async deriveKeylessAccount(e){return o({aptosConfig:this.config,...e})}};export{t as a};
-//# sourceMappingURL=chunk-US26M7LP.mjs.map

package/dist/esm/chunk-WP7YNQOI.mjs

@@ -1,2 +0,0 @@
-import{c as E}from"./chunk-U2XWRAPL.mjs";import{e as x,f as K}from"./chunk-SEJ2XNM7.mjs";import{a as g}from"./chunk-GFW5KSAZ.mjs";import{a as m,l as h,m as A}from"./chunk-4X4HJL3N.mjs";import{b as S}from"./chunk-CYIEYPXQ.mjs";import{c as d}from"./chunk-S5HG2QUD.mjs";import{b as l}from"./chunk-TVRJ3M7B.mjs";import{b as a}from"./chunk-AOCNYMMX.mjs";import{jwtDecode as b}from"jwt-decode";import{bls12_381 as p}from"@noble/curves/bls12-381";var v="APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST";function w(e){return new TextEncoder().encode(e)}var I=p.G2.hashToCurve(w("APTOS_KEYLESS_PEPPER_PINKAS_VUF_SECRET_KEY_BASE"),{DST:v}).toAffine();function j(e){let{jwt:i,uidKey:t}=e,r=b(i),o=new l;o.serializeStr(r.iss),o.serializeStr(r.aud),o.serializeStr(r[t||"sub"]),o.serializeStr(t||"sub");let s=o.toUint8Array(),n=p.G1.hashToCurve(s,{DST:"APTOS_PEPPER_SERVICE_BLS12381_VUF_DST"}).toAffine();return p.G1.ProjectivePoint.fromAffine(n)}async function C(e){let{aptosConfig:i,pepperInput:t,pepperBase:r}=e,{data:o}=await E({aptosConfig:i,path:"vrf-pub-key",originMethod:"getPepper"}),s=p.G2.ProjectivePoint.fromHex(o.vrf_public_key_hex_string);return p.verifyShortSignature(r,t,s)}async function F(e){let{aptosConfig:i,jwt:t,ephemeralKeyPair:r,uidKey:o,verify:s}=e,{derivationPath:n}=e,f={jwt_b64:t,epk:r.publicKey.bcsToHex().toStringWithoutPrefix(),exp_date_secs:Number(r.expiryDateSecs),epk_blinder:a.fromHexInput(r.blinder).toStringWithoutPrefix(),uid_key:o},{data:c}=await x({aptosConfig:i,path:"fetch",body:f,originMethod:"getPepper",overrides:{WITH_CREDENTIALS:!1}}),P=a.fromHexInput(c.signature).toUint8Array();if(s&&!C({aptosConfig:i,pepperBase:P,pepperInput:j(e)}))throw new Error("Unable to verify");let u=p.pairing(p.G1.ProjectivePoint.fromHex(P),p.G2.ProjectivePoint.fromAffine(I));return n===void 0&&(n=d),g.fromDerivationPath(n,p.fields.Fp12.toBytes(u)).slice(0,31)}async function H(e){let{aptosConfig:i,jwt:t,ephemeralKeyPair:r,pepper:o,uidKey:s,extraFieldKey:n}=e,f=b(t),c;if(n){let T=f[n];c=`"${n}":"${T}",`}let P={jwt_b64:t,epk:r.publicKey.bcsToHex().toStringWithoutPrefix(),epk_blinder:a.fromHexInput(r.blinder).toStringWithoutPrefix(),exp_date_secs:Number(r.expiryDateSecs),exp_horizon_secs:m,pepper:a.fromHexInput(o).toStringWithoutPrefix(),extra_field:n,uid_key:s||"sub"},{data:u}=await K({aptosConfig:i,path:"prove",body:P,originMethod:"getProof",overrides:{WITH_CREDENTIALS:!1}}),y=u.proof,_=new h({a:y.a,b:y.b,c:y.c});return new A({proof:_,extraField:c,trainingWheelsSignature:S.fromHex(u.training_wheels_signature)})}async function O(e){let{fetchProofAsync:i}=e,{pepper:t}=e;if(t===void 0)t=await F(e);else if(a.fromHexInput(t).toUint8Array().length!==31)throw new Error("Pepper needs to be 31 bytes");let r=H({...e,pepper:t}),o=i?r:await r;return g.fromJWTAndProof({...e,proofFetcherOrData:o,pepper:t})}export{F as a,H as b,O as c};
-//# sourceMappingURL=chunk-WP7YNQOI.mjs.map

package/dist/esm/chunk-WP7YNQOI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/keyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file contains the underlying implementations for exposed API surface in\n * the {@link api/oidb}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * faucet namespace and without having a dependency cycle error.\n */\nimport { jwtDecode } from \"jwt-decode\";\nimport { bls12_381 as bls } from \"@noble/curves/bls12-381\";\nimport { ProjPointType } from \"@noble/curves/abstract/weierstrass\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { getAptosPepperService, postAptosPepperService, postAptosProvingService } from \"../client\";\nimport {\n  APTOS_BIP44_DEFAULT_DERIVATION_PATH,\n  EPK_HORIZON_SECS,\n  EphemeralSignature,\n  Groth16Zkp,\n  Hex,\n  SignedGroth16Signature,\n} from \"../core\";\nimport { HexInput } from \"../types\";\nimport { Serializer } from \"../bcs\";\nimport { EphemeralKeyPair, KeylessAccount } from \"../account\";\nimport { PepperFetchResponse, ProverResponse } from \"../types/keyless\";\n\nconst APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST = \"APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST\";\n\nfunction stringToUint8Array(str: string): Uint8Array {\n  const encoder = new TextEncoder();\n  return encoder.encode(str);\n}\n\nconst PINKAS_VUF_SECRET_KEY_BASE_AFFINE = bls.G2.hashToCurve(\n  stringToUint8Array(\"APTOS_KEYLESS_PEPPER_PINKAS_VUF_SECRET_KEY_BASE\"),\n  { DST: APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST },\n).toAffine();\n\nfunction getPepperInput(args: { jwt: string; uidKey?: string }): ProjPointType<bigint> {\n  const { jwt, uidKey } = args;\n  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);\n  const serializer = new Serializer();\n  serializer.serializeStr(jwtPayload.iss);\n  serializer.serializeStr(jwtPayload.aud);\n  serializer.serializeStr(jwtPayload[uidKey || \"sub\"]);\n  serializer.serializeStr(uidKey || \"sub\");\n  const serial = serializer.toUint8Array();\n  const msg = bls.G1.hashToCurve(serial, { DST: \"APTOS_PEPPER_SERVICE_BLS12381_VUF_DST\" }).toAffine();\n  const pp = bls.G1.ProjectivePoint.fromAffine(msg);\n  return pp;\n}\n\nasync function verifyPepperBase(args: {\n  aptosConfig: AptosConfig;\n  pepperInput: ProjPointType<bigint>;\n  pepperBase: Uint8Array;\n}): Promise<boolean> {\n  const { aptosConfig, pepperInput, pepperBase } = args;\n  const { data: pubKeyResponse } = await getAptosPepperService<any, { vrf_public_key_hex_string: string }>({\n    aptosConfig,\n    path: \"vrf-pub-key\",\n    originMethod: \"getPepper\",\n  });\n  const publicKeyFromService = bls.G2.ProjectivePoint.fromHex(pubKeyResponse.vrf_public_key_hex_string);\n  return bls.verifyShortSignature(pepperBase, pepperInput, publicKeyFromService);\n}\n\nexport async function getPepper(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  derivationPath?: string;\n  verify?: boolean;\n}): Promise<Uint8Array> {\n  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, verify } = args;\n  let { derivationPath } = args;\n\n  const body = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),\n    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    uid_key: uidKey,\n  };\n  // console.log(JSON.stringify(body));\n  const { data } = await postAptosPepperService<any, PepperFetchResponse>({\n    aptosConfig,\n    path: \"fetch\",\n    body,\n    originMethod: \"getPepper\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n  const pepperBase = Hex.fromHexInput(data.signature).toUint8Array();\n\n  if (verify) {\n    const pepperVerified = verifyPepperBase({ aptosConfig, pepperBase, pepperInput: getPepperInput(args) });\n    if (!pepperVerified) {\n      throw new Error(\"Unable to verify\");\n    }\n  }\n  // 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).\n  // 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.\n  const newPepperBase = bls.pairing(\n    bls.G1.ProjectivePoint.fromHex(pepperBase),\n    bls.G2.ProjectivePoint.fromAffine(PINKAS_VUF_SECRET_KEY_BASE_AFFINE),\n  );\n\n  if (derivationPath === undefined) {\n    derivationPath = APTOS_BIP44_DEFAULT_DERIVATION_PATH;\n  }\n  const pepper = KeylessAccount.fromDerivationPath(derivationPath, bls.fields.Fp12.toBytes(newPepperBase));\n  return pepper.slice(0, 31);\n}\n\nexport async function getProof(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  pepper: HexInput;\n  uidKey?: string;\n  extraFieldKey?: string;\n}): Promise<SignedGroth16Signature> {\n  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;\n  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);\n  let extraField;\n  if (extraFieldKey) {\n    const extraFieldVal = jwtPayload[extraFieldKey];\n    extraField = `\"${extraFieldKey}\":\"${extraFieldVal}\",`;\n  }\n  const json = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),\n    exp_horizon_secs: EPK_HORIZON_SECS,\n    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),\n    extra_field: extraFieldKey,\n    uid_key: uidKey || \"sub\",\n  };\n\n  const { data } = await postAptosProvingService<any, ProverResponse>({\n    aptosConfig,\n    path: \"prove\",\n    body: json,\n    originMethod: \"getProof\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n\n  const proofPoints = data.proof;\n  const proof = new Groth16Zkp({\n    a: proofPoints.a,\n    b: proofPoints.b,\n    c: proofPoints.c,\n  });\n\n  const signedProof = new SignedGroth16Signature({\n    proof,\n    extraField,\n    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),\n  });\n  return signedProof;\n}\n\nexport async function deriveKeylessAccount(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  pepper?: HexInput;\n  extraFieldKey?: string;\n  fetchProofAsync?: boolean;\n}): Promise<KeylessAccount> {\n  const { fetchProofAsync } = args;\n  let { pepper } = args;\n  if (pepper === undefined) {\n    pepper = await getPepper(args);\n  } else if (Hex.fromHexInput(pepper).toUint8Array().length !== 31) {\n    throw new Error(\"Pepper needs to be 31 bytes\");\n  }\n\n  const proofPromise = getProof({ ...args, pepper });\n  const proof = fetchProofAsync ? proofPromise : await proofPromise;\n\n  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proofFetcherOrData: proof, pepper });\n\n    return keylessAccount;\n}\n"],"mappings":"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","names":["jwtDecode","bls","APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST","stringToUint8Array","str","PINKAS_VUF_SECRET_KEY_BASE_AFFINE","bls","getPepperInput","args","jwt","uidKey","jwtPayload","jwtDecode","serializer","Serializer","serial","msg","verifyPepperBase","aptosConfig","pepperInput","pepperBase","pubKeyResponse","getAptosPepperService","publicKeyFromService","getPepper","ephemeralKeyPair","verify","derivationPath","body","Hex","data","postAptosPepperService","newPepperBase","APTOS_BIP44_DEFAULT_DERIVATION_PATH","KeylessAccount","getProof","pepper","extraFieldKey","extraField","extraFieldVal","json","EPK_HORIZON_SECS","postAptosProvingService","proofPoints","proof","Groth16Zkp","SignedGroth16Signature","EphemeralSignature","deriveKeylessAccount","fetchProofAsync","proofPromise"]}