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

package/src/api/general.ts

@@ -3,14 +3,13 @@
 
 import { AptosConfig } from "./aptosConfig";
 import {
-  getBlockByHeight,
-  getBlockByVersion,
   getChainTopUserTransactions,
   getIndexerLastSuccessVersion,
   getLedgerInfo,
   getProcessorStatus,
   queryIndexer,
 } from "../internal/general";
+import { getBlockByHeight, getBlockByVersion } from "../internal/transaction";
 import { view } from "../internal/view";
 import {
   AnyNumber,

package/src/api/keyless.ts

@@ -2,9 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
-import { KeylessConfiguration } from "../core";
-import { deriveKeylessAccount, getKeylessConfig, getPepper } from "../internal/keyless";
-import { HexInput, LedgerVersionArg } from "../types";
+import { deriveKeylessAccount, getPepper } from "../internal/keyless";
+import { HexInput } from "../types";
 import { AptosConfig } from "./aptosConfig";
 
 /**
@@ -13,16 +12,6 @@ import { AptosConfig } from "./aptosConfig";
 export class Keyless {
   constructor(readonly config: AptosConfig) {}
 
-  /**
-   * Gets the parameters of how Keyless Accounts are configured on chain.
-   *
-   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-   * @returns KeylessConfiguration
-   */
-  async getKeylessConfig(options?: LedgerVersionArg): Promise<KeylessConfiguration> {
-    return getKeylessConfig({ aptosConfig: this.config, options });
-  }
-
   /**
    * Fetches the pepper from the Aptos pepper service API.
    *

package/src/client/core.ts

@@ -101,7 +101,7 @@ 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) {
+    if (result.status >= 400) {
       throw new AptosApiError(options, result, `${response.data}`);
     }
   }

package/src/client/types.ts

@@ -41,7 +41,7 @@ export class AptosApiError extends Error {
 
   readonly statusText: string;
 
-  readonly data: { message: string; error_code?: string; vm_error_code?: number };
+  readonly data: any;
 
   readonly request: AptosRequest;
 

package/src/core/crypto/keyless.ts

@@ -1,6 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+import { JwtPayload, jwtDecode } from "jwt-decode";
 import { AccountPublicKey, PublicKey } from "./publicKey";
 import { Signature } from "./signature";
 import { Deserializer, Serializable, Serializer } from "../../bcs";
@@ -138,6 +139,18 @@ export class KeylessPublicKey extends AccountPublicKey {
     computeIdCommitment(args);
     return new KeylessPublicKey(args.iss, computeIdCommitment(args));
   }
+
+  static fromJWTAndPepper(args: { jwt: string; pepper: HexInput; uidKey?: string }): KeylessPublicKey {
+    const { jwt, pepper, uidKey = "sub" } = args;
+    const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);
+    const iss = jwtPayload.iss!;
+    if (typeof jwtPayload.aud !== "string") {
+      throw new Error("aud was not found or an array of values");
+    }
+    const aud = jwtPayload.aud!;
+    const uidVal = jwtPayload[uidKey];
+    return KeylessPublicKey.create({ iss, uidKey, uidVal, aud, pepper });
+  }
 }
 
 function computeIdCommitment(args: { uidKey: string; uidVal: string; aud: string; pepper: HexInput }): Uint8Array {
@@ -254,6 +267,7 @@ export class KeylessSignature extends Signature {
             new Groth16Zkp({ a: new Uint8Array(32), b: new Uint8Array(64), c: new Uint8Array(32) }),
             ZkpVariant.Groth16,
           ),
+          expHorizonSecs: 0,
         }),
         EphemeralCertificateVariant.ZkProof,
       ),
@@ -438,7 +452,7 @@ export class ZeroKnowledgeSig extends Signature {
   /**
    * The max lifespan of the proof
    */
-  readonly expHorizonSecs: bigint;
+  readonly expHorizonSecs: number;
 
   /**
    * A key value pair on the JWT token that can be specified on the signature which would reveal the value on chain.
@@ -458,19 +472,13 @@ export class ZeroKnowledgeSig extends Signature {
 
   constructor(args: {
     proof: ZkProof;
-    expHorizonSecs?: bigint;
+    expHorizonSecs: number;
     extraField?: string;
     overrideAudVal?: string;
     trainingWheelsSignature?: EphemeralSignature;
   }) {
     super();
-    const {
-      proof,
-      expHorizonSecs = BigInt(EPK_HORIZON_SECS),
-      trainingWheelsSignature,
-      extraField,
-      overrideAudVal,
-    } = args;
+    const { proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal } = args;
     this.proof = proof;
     this.expHorizonSecs = expHorizonSecs;
     this.trainingWheelsSignature = trainingWheelsSignature;
@@ -506,7 +514,7 @@ export class ZeroKnowledgeSig extends Signature {
 
   static deserialize(deserializer: Deserializer): ZeroKnowledgeSig {
     const proof = ZkProof.deserialize(deserializer);
-    const expHorizonSecs = deserializer.deserializeU64();
+    const expHorizonSecs = Number(deserializer.deserializeU64());
     const extraField = deserializer.deserializeOptionStr();
     const overrideAudVal = deserializer.deserializeOptionStr();
     const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);
@@ -515,7 +523,7 @@ export class ZeroKnowledgeSig extends Signature {
 
   static load(deserializer: Deserializer): ZeroKnowledgeSig {
     const proof = ZkProof.deserialize(deserializer);
-    const expHorizonSecs = deserializer.deserializeU64();
+    const expHorizonSecs = Number(deserializer.deserializeU64());
     const extraField = deserializer.deserializeOptionStr();
     const overrideAudVal = deserializer.deserializeOptionStr();
     const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);
@@ -523,9 +531,18 @@ export class ZeroKnowledgeSig extends Signature {
   }
 }
 
+/**
+ * A class which represents the on-chain configuration for how Keyless accounts work
+ */
 export class KeylessConfiguration {
+  /**
+   * The verification key used to verify Groth16 proofs on chain
+   */
   readonly verficationKey: Groth16VerificationKey;
 
+  /**
+   * The maximum lifespan of an ephemeral key pair.  This is configured on chain.
+   */
   readonly maxExpHorizonSecs: number;
 
   constructor(verficationKey: Groth16VerificationKey, maxExpHorizonSecs: number) {
@@ -547,15 +564,35 @@ export class KeylessConfiguration {
   }
 }
 
+/**
+ * A representation of the verification key stored on chain used to verify Groth16 proofs
+ */
 class Groth16VerificationKey {
+  // The docstrings below are borrowed from ark-groth16
+
+  /**
+   * The `alpha * G`, where `G` is the generator of G1
+   */
   readonly alphaG1: G1Bytes;
 
+  /**
+   * The `alpha * H`, where `H` is the generator of G2
+   */
   readonly betaG2: G2Bytes;
 
+  /**
+   * The `delta * H`, where `H` is the generator of G2
+   */
   readonly deltaG2: G2Bytes;
 
+  /**
+   * The `gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H`, where H is the generator of G1
+   */
   readonly gammaAbcG1: G1Bytes[];
 
+  /**
+   * The `gamma * H`, where `H` is the generator of G2
+   */
   readonly gammaG2: G2Bytes;
 
   constructor(args: {

package/src/internal/general.ts

@@ -10,14 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { getAptosFullNode, postAptosIndexer } from "../client";
-import {
-  AnyNumber,
-  Block,
-  GetChainTopUserTransactionsResponse,
-  GetProcessorStatusResponse,
-  GraphqlQuery,
-  LedgerInfo,
-} from "../types";
+import { GetChainTopUserTransactionsResponse, GetProcessorStatusResponse, GraphqlQuery, LedgerInfo } from "../types";
 import { GetChainTopUserTransactionsQuery, GetProcessorStatusQuery } from "../types/generated/operations";
 import { GetChainTopUserTransactions, GetProcessorStatus } from "../types/generated/queries";
 import { ProcessorType } from "../utils/const";
@@ -32,36 +25,6 @@ export async function getLedgerInfo(args: { aptosConfig: AptosConfig }): Promise
   return data;
 }
 
-export async function getBlockByVersion(args: {
-  aptosConfig: AptosConfig;
-  ledgerVersion: AnyNumber;
-  options?: { withTransactions?: boolean };
-}): Promise<Block> {
-  const { aptosConfig, ledgerVersion, options } = args;
-  const { data } = await getAptosFullNode<{}, Block>({
-    aptosConfig,
-    originMethod: "getBlockByVersion",
-    path: `blocks/by_version/${ledgerVersion}`,
-    params: { with_transactions: options?.withTransactions },
-  });
-  return data;
-}
-
-export async function getBlockByHeight(args: {
-  aptosConfig: AptosConfig;
-  blockHeight: AnyNumber;
-  options?: { withTransactions?: boolean };
-}): Promise<Block> {
-  const { aptosConfig, blockHeight, options } = args;
-  const { data } = await getAptosFullNode<{}, Block>({
-    aptosConfig,
-    originMethod: "getBlockByHeight",
-    path: `blocks/by_height/${blockHeight}`,
-    params: { with_transactions: options?.withTransactions },
-  });
-  return data;
-}
-
 export async function getChainTopUserTransactions(args: {
   aptosConfig: AptosConfig;
   limit: number;

package/src/internal/keyless.ts

@@ -11,7 +11,6 @@ import { AptosConfig } from "../api/aptosConfig";
 import { getAptosFullNode, postAptosPepperService, postAptosProvingService } from "../client";
 import {
   AccountAddress,
-  EPK_HORIZON_SECS,
   EphemeralSignature,
   Groth16Zkp,
   Hex,
@@ -31,15 +30,21 @@ import {
 } from "../types/keyless";
 import { memoizeAsync } from "../utils/memoize";
 
-export async function getKeylessConfig(args: {
+/**
+ * Gets the parameters of how Keyless Accounts are configured on chain including the verifying key and the max expiry horizon
+ *
+ * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+ * @returns KeylessConfiguration
+ */
+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);
+      const config = await getKeylessConfigurationResource(args);
+      const vk = await getGroth16VerificationKeyResource(args);
       return KeylessConfiguration.create(vk, Number(config.max_exp_horizon_secs));
     },
     `keyless-configuration-${aptosConfig.network}`,
@@ -47,7 +52,13 @@ export async function getKeylessConfig(args: {
   )();
 }
 
-async function getKeylessConfiguration(args: {
+/**
+ * Gets the KeylessConfiguration set on chain
+ *
+ * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+ * @returns KeylessConfigurationResponse
+ */
+async function getKeylessConfigurationResource(args: {
   aptosConfig: AptosConfig;
   options?: LedgerVersionArg;
 }): Promise<KeylessConfigurationResponse> {
@@ -63,7 +74,13 @@ async function getKeylessConfiguration(args: {
   return data.data;
 }
 
-async function getGroth16VerificationKey(args: {
+/**
+ * Gets the Groth16VerificationKey set on chain
+ *
+ * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+ * @returns Groth16VerificationKeyResponse
+ */
+async function getGroth16VerificationKeyResource(args: {
   aptosConfig: AptosConfig;
   options?: LedgerVersionArg;
 }): Promise<Groth16VerificationKeyResponse> {
@@ -86,14 +103,14 @@ export async function getPepper(args: {
   uidKey?: string;
   derivationPath?: string;
 }): Promise<Uint8Array> {
-  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, derivationPath } = args;
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey = "sub", derivationPath } = args;
 
   const body = {
     jwt_b64: jwt,
     epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
     exp_date_secs: ephemeralKeyPair.expiryDateSecs,
     epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
-    uid_key: uidKey || "sub",
+    uid_key: uidKey,
     derivation_path: derivationPath,
   };
   const { data } = await postAptosPepperService<PepperFetchRequest, PepperFetchResponse>({
@@ -113,19 +130,18 @@ export async function getProof(args: {
   pepper: HexInput;
   uidKey?: string;
 }): Promise<ZeroKnowledgeSig> {
-  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey } = args;
+  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey = "sub" } = args;
+  const { maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });
   const json = {
     jwt_b64: jwt,
     epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
     epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
     exp_date_secs: ephemeralKeyPair.expiryDateSecs,
-    exp_horizon_secs: EPK_HORIZON_SECS,
+    exp_horizon_secs: maxExpHorizonSecs,
     pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
-    uid_key: uidKey || "sub",
+    uid_key: uidKey,
   };
 
-  console.log(JSON.stringify(json))
-
   const { data } = await postAptosProvingService<ProverRequest, ProverResponse>({
     aptosConfig,
     path: "prove",
@@ -144,6 +160,7 @@ export async function getProof(args: {
   const signedProof = new ZeroKnowledgeSig({
     proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),
     trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),
+    expHorizonSecs: maxExpHorizonSecs,
   });
   return signedProof;
 }
@@ -171,7 +188,7 @@ export async function deriveKeylessAccount(args: {
   const proofPromise = getProof({ ...args, pepper });
   const proof = proofFetchCallback ? proofPromise : await proofPromise;
 
-  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proof, pepper, proofFetchCallback });
+  const keylessAccount = KeylessAccount.create({ ...args, proof, pepper, proofFetchCallback });
 
   return keylessAccount;
 }

package/src/internal/transaction.ts

@@ -19,6 +19,7 @@ import {
   type TransactionResponse,
   WaitForTransactionOptions,
   CommittedTransactionResponse,
+  Block,
 } from "../types";
 import { DEFAULT_TXN_TIMEOUT_SEC, ProcessorType } from "../utils/const";
 import { sleep } from "../utils/helpers";
@@ -279,3 +280,94 @@ export class FailedTransactionError extends Error {
     this.transaction = transaction;
   }
 }
+
+export async function getBlockByVersion(args: {
+  aptosConfig: AptosConfig;
+  ledgerVersion: AnyNumber;
+  options?: { withTransactions?: boolean };
+}): Promise<Block> {
+  const { aptosConfig, ledgerVersion, options } = args;
+  const { data: block } = await getAptosFullNode<{}, Block>({
+    aptosConfig,
+    originMethod: "getBlockByVersion",
+    path: `blocks/by_version/${ledgerVersion}`,
+    params: { with_transactions: options?.withTransactions },
+  });
+
+  return fillBlockTransactions({ block, ...args });
+}
+
+export async function getBlockByHeight(args: {
+  aptosConfig: AptosConfig;
+  blockHeight: AnyNumber;
+  options?: { withTransactions?: boolean };
+}): Promise<Block> {
+  const { aptosConfig, blockHeight, options } = args;
+  const { data: block } = await getAptosFullNode<{}, Block>({
+    aptosConfig,
+    originMethod: "getBlockByHeight",
+    path: `blocks/by_height/${blockHeight}`,
+    params: { with_transactions: options?.withTransactions },
+  });
+  return fillBlockTransactions({ block, ...args });
+}
+
+/**
+ * Fills in the block with transactions if not enough were returned
+ * @param args
+ */
+async function fillBlockTransactions(args: {
+  aptosConfig: AptosConfig;
+  block: Block;
+  options?: { withTransactions?: boolean };
+}) {
+  const { aptosConfig, block, options } = args;
+  if (options?.withTransactions) {
+    // Transactions should be filled, but this ensures it
+    block.transactions = block.transactions ?? [];
+
+    const lastTxn = block.transactions[block.transactions.length - 1];
+    const firstVersion = BigInt(block.first_version);
+    const lastVersion = BigInt(block.last_version);
+
+    // Convert the transaction to the type
+    const curVersion: string | undefined = (lastTxn as any)?.version;
+    let latestVersion;
+
+    // This time, if we don't have any transactions, we will try once with the start of the block
+    if (curVersion === undefined) {
+      latestVersion = firstVersion - 1n;
+    } else {
+      latestVersion = BigInt(curVersion);
+    }
+
+    // If we have all the transactions in the block, we can skip out, otherwise we need to fill the transactions
+    if (latestVersion === lastVersion) {
+      return block;
+    }
+
+    // For now, we will grab all the transactions in groups of 100, but we can make this more efficient by trying larger
+    // amounts
+    const fetchFutures = [];
+    const pageSize = 100n;
+    for (let i = latestVersion + 1n; i < lastVersion; i += BigInt(100)) {
+      fetchFutures.push(
+        getTransactions({
+          aptosConfig,
+          options: {
+            offset: i,
+            limit: Math.min(Number(pageSize), Number(lastVersion - i + 1n)),
+          },
+        }),
+      );
+    }
+
+    // Combine all the futures
+    const responses = await Promise.all(fetchFutures);
+    for (const txns of responses) {
+      block.transactions.push(...txns);
+    }
+  }
+
+  return block;
+}

package/src/utils/apiEndpoints.ts

@@ -33,7 +33,7 @@ export const NetworkToPepperAPI: Record<string, string> = {
 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://prover.keyless.devnet.aptoslabs.com/v0",
+  devnet: "https://api.devnet.aptoslabs.com/keyless/prover/v0",
   // Use the devnet service for local environment
   local: "https://api.devnet.aptoslabs.com/keyless/prover/v0",
 };

package/src/utils/helpers.ts

@@ -26,6 +26,12 @@ export function floorToWholeHour(timestampInSeconds: number): number {
   return Math.floor(date.getTime() / 1000);
 }
 
+export function ceilingToWholeHour(timestampInSeconds: number): number {
+  const date = new Date(timestampInSeconds * 1000);
+  date.setHours(date.getHours() + 1);
+  return floorToWholeHour(date.getTime() / 1000)
+}
+
 export function base64UrlDecode(base64Url: string): string {
   // Replace base64url-specific characters
   const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");

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.2";
+export const VERSION = "1.16.0-zeta.3";

package/dist/esm/chunk-4TDMJQOJ.mjs

@@ -1,2 +0,0 @@
-import{a as v}from"./chunk-LYOUEPDG.mjs";import{a as x}from"./chunk-VJ3OBIFQ.mjs";import{a as E}from"./chunk-KGHBTSDR.mjs";import{d as y}from"./chunk-RYRID5HT.mjs";import{a as u,b as f}from"./chunk-XGDLSWBF.mjs";import{i as S,j as F,k as A,n as d}from"./chunk-T4HO5JMQ.mjs";import{b as K}from"./chunk-F3ZVWLDH.mjs";import{d as b}from"./chunk-QHB5A5YP.mjs";import{a as g}from"./chunk-3IFR6T3V.mjs";import{a as P}from"./chunk-UMLUOYFK.mjs";import{b as w}from"./chunk-AOCNYMMX.mjs";import{jwtDecode as H}from"jwt-decode";import Z from"eventemitter3";var ee={"https://accounts.google.com":"https://www.googleapis.com/oauth2/v3/certs"},s=class s extends P{constructor(e){super();let{address:r,ephemeralKeyPair:t,uidKey:o,uidVal:n,aud:a,pepper:c,proofOrFetcher:i,proofFetchCallback:p,jwt:l}=e;if(this.ephemeralKeyPair=t,this.publicKey=S.create(e),this.accountAddress=r?K.from(r):this.publicKey.authKey().derivedAddress(),this.uidKey=o,this.uidVal=n,this.aud=a,this.jwt=l,this.emitter=new Z,this.proofOrPromise=i,i instanceof d)this.proof=i;else{if(p===void 0)throw new Error("Must provide callback for async proof fetch");this.emitter.on("proofFetchFinish",async z=>{await p(z),this.emitter.removeAllListeners()}),this.init(i)}this.signingScheme=2;let h=w.fromHexInput(c).toUint8Array();if(h.length!==s.PEPPER_LENGTH)throw new Error(`Pepper length in bytes should be ${s.PEPPER_LENGTH}`);this.pepper=h,this.isJwtValid=!0}async init(e){try{this.proof=await e,this.emitter.emit("proofFetchFinish",{status:"Success"})}catch(r){r instanceof Error?this.emitter.emit("proofFetchFinish",{status:"Failed",error:r.toString()}):this.emitter.emit("proofFetchFinish",{status:"Failed",error:"Unknown"})}}serialize(e){if(e.serializeStr(this.jwt),e.serializeStr(this.uidKey),e.serializeFixedBytes(this.pepper),this.ephemeralKeyPair.serialize(e),this.proof===void 0)throw new Error("Connot serialize - proof undefined");this.proof.serialize(e)}static deserialize(e){let r=e.deserializeStr(),t=e.deserializeStr(),o=e.deserializeFixedBytes(31),n=x.deserialize(e),a=d.deserialize(e);return s.fromJWTAndProof({proof:a,pepper:o,uidKey:t,jwt:r,ephemeralKeyPair:n})}isExpired(){return this.ephemeralKeyPair.isExpired()}signWithAuthenticator(e){let r=new f(this.sign(e)),t=new u(this.publicKey);return new y(t,r)}signTransactionWithAuthenticator(e){let r=new f(this.signTransaction(e)),t=new u(this.publicKey);return new y(t,r)}async waitForProofFetch(){this.proofOrPromise instanceof Promise&&await this.proofOrPromise}sign(e){let{expiryDateSecs:r}=this.ephemeralKeyPair;if(this.isExpired())throw new Error("EphemeralKeyPair is expired");if(this.proof===void 0)throw new Error("Proof not defined");let t=this.ephemeralKeyPair.getPublicKey(),o=this.ephemeralKeyPair.sign(e);return new F({jwtHeader:b(this.jwt.split(".")[0]),ephemeralCertificate:new A(this.proof,0),expiryDateSecs:r,ephemeralPublicKey:t,ephemeralSignature:o})}signTransaction(e){if(this.proof===void 0)throw new Error("Proof not found");let r=E(e),o=new m(r,this.proof.proof).hash();return this.sign(o)}verifySignature(e){throw new Error("Not implemented")}static fromBytes(e){return s.deserialize(new g(e))}static fromJWTAndProof(e){let{proof:r,jwt:t,ephemeralKeyPair:o,pepper:n,proofFetchCallback:a}=e,c=e.uidKey??"sub",i=H(t),p=i.iss;if(typeof i.aud!="string")throw new Error("aud was not found or an array of values");let l=i.aud,h=i[c];return new s({proofOrFetcher:r,ephemeralKeyPair:o,iss:p,uidKey:c,uidVal:h,aud:l,pepper:n,jwt:t,proofFetchCallback:a})}};s.PEPPER_LENGTH=31;var T=s,m=class extends v{constructor(e,r){super();this.transaction=e,this.proof=r,this.domainSeparator="APTOS::TransactionAndProof"}serialize(e){e.serializeFixedBytes(this.transaction.bcsToBytes()),e.serializeOption(this.proof)}};export{ee as a,T as b,m as c};
-//# sourceMappingURL=chunk-4TDMJQOJ.mjs.map

package/dist/esm/chunk-4TDMJQOJ.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 EventEmitter from \"eventemitter3\";\nimport { EphemeralCertificateVariant, HexInput, SigningScheme } from \"../types\";\nimport { AccountAddress } from \"../core/accountAddress\";\nimport {\n  AnyPublicKey,\n  AnySignature,\n  KeylessPublicKey,\n  KeylessSignature,\n  EphemeralCertificate,\n  Signature,\n  ZeroKnowledgeSig,\n  ZkProof,\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, Serializable, Serializer } from \"../bcs\";\nimport { deriveTransactionType } from \"../transactions/transactionBuilder/signingMessage\";\nimport { AnyRawTransaction, AnyRawTransactionInstance } from \"../transactions/types\";\nimport { AptsoDomainSeparator, CryptoHashable } from \"../core/crypto/cryptoHasher\";\nimport { base64UrlDecode } from \"../utils/helpers\";\n\nexport const IssuerToJwkEndpoint: Record<string, string> = {\n  \"https://accounts.google.com\": \"https://www.googleapis.com/oauth2/v3/certs\",\n};\n\n/**\n * Account implementation for the Keyless authentication scheme.\n *\n * Used to represent a Keyless based account and sign transactions with it.\n *\n * Use KeylessAccount.fromJWTAndProof to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.\n *\n * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,\n * EphemeralKeyPair, and corresponding proof.\n */\nexport class KeylessAccount extends Serializable implements Account {\n  static readonly PEPPER_LENGTH: number = 31;\n\n  /**\n   * The KeylessPublicKey associated with the account\n   */\n  readonly publicKey: KeylessPublicKey;\n\n  /**\n   * The EphemeralKeyPair used to generate sign.\n   */\n  readonly ephemeralKeyPair: EphemeralKeyPair;\n\n  /**\n   * The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.\n   */\n  readonly uidKey: string;\n\n  /**\n   * The value of the uidKey claim on the JWT.  This intended to be a stable user identifier.\n   */\n  readonly uidVal: string;\n\n  /**\n   * The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's\n   * OIDC registration with the identity provider.\n   */\n  readonly aud: string;\n\n  /**\n   * A value contains 31 bytes of entropy that preserves privacy of the account. Typically fetched from a pepper provider.\n   */\n  readonly pepper: Uint8Array;\n\n  /**\n   * Account address associated with the account\n   */\n  readonly accountAddress: AccountAddress;\n\n  /**\n   * The zero knowledge signature (if ready) which contains the proof used to validate the EphemeralKeyPair.\n   */\n  proof: ZeroKnowledgeSig | undefined;\n\n  /**\n   * The proof of the EphemeralKeyPair or a promise that provides the proof.  This is used to allow for awaiting on\n   * fetching the proof.\n   */\n  readonly proofOrPromise: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n\n  /**\n   * Signing scheme used to sign transactions\n   */\n  readonly signingScheme: SigningScheme;\n\n  /**\n   * The JWT token used to derive the account\n   */\n  private jwt: string;\n\n  /**\n   * A value that caches the JWT's validity.  A JWT becomes invalid when it's corresponding JWK is rotated from the\n   * identity provider's JWK keyset.\n   */\n  private isJwtValid: boolean;\n\n  /**\n   * An event emitter used to assist in handling asycronous proof fetching.\n   */\n  private readonly emitter: EventEmitter<ProofFetchEvents>;\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    proofOrFetcher: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    proofFetchCallback?: ProofFetchCallback;\n    jwt: string;\n  }) {\n    super();\n    const { address, ephemeralKeyPair, uidKey, uidVal, aud, pepper, proofOrFetcher, proofFetchCallback, jwt } = args;\n    this.ephemeralKeyPair = ephemeralKeyPair;\n    this.publicKey = KeylessPublicKey.create(args);\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    this.emitter = new EventEmitter<ProofFetchEvents>();\n    this.proofOrPromise = proofOrFetcher;\n    if (proofOrFetcher instanceof ZeroKnowledgeSig) {\n      this.proof = proofOrFetcher;\n    } else {\n      if (proofFetchCallback === undefined) {\n        throw new Error(\"Must provide callback for async proof fetch\");\n      }\n      this.emitter.on(\"proofFetchFinish\", async (status) => {\n        await proofFetchCallback(status);\n        this.emitter.removeAllListeners();\n      });\n      this.init(proofOrFetcher);\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    this.isJwtValid = true;\n  }\n\n  /**\n   * This initializes the asyncronous proof fetch\n   * @return\n   */\n  async init(promise: Promise<ZeroKnowledgeSig>) {\n    try {\n      this.proof = await promise;\n      this.emitter.emit(\"proofFetchFinish\", { status: \"Success\" });\n    } catch (error) {\n      if (error instanceof Error) {\n        this.emitter.emit(\"proofFetchFinish\", { status: \"Failed\", error: error.toString() });\n      } else {\n        this.emitter.emit(\"proofFetchFinish\", { status: \"Failed\", error: \"Unknown\" });\n      }\n    }\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeStr(this.jwt);\n    serializer.serializeStr(this.uidKey);\n    serializer.serializeFixedBytes(this.pepper);\n    this.ephemeralKeyPair.serialize(serializer);\n    if (this.proof === undefined) {\n      throw new Error(\"Connot serialize - proof undefined\");\n    }\n    this.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 = ZeroKnowledgeSig.deserialize(deserializer);\n    return KeylessAccount.fromJWTAndProof({\n      proof,\n      pepper,\n      uidKey,\n      jwt,\n      ephemeralKeyPair,\n    });\n  }\n\n  /**\n   * Checks if the proof is expired.  If so the account must be rederived with a new EphemeralKeyPair\n   * and JWT token.\n   * @return boolean\n   */\n  isExpired(): boolean {\n    return this.ephemeralKeyPair.isExpired();\n  }\n\n  /**\n   * Sign a message using Keyless.\n   * @param message the message to sign, as binary input\n   * @return the AccountAuthenticator containing the signature, together with the account's public key\n   */\n  signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey {\n    const signature = new AnySignature(this.sign(message));\n    const publicKey = new AnyPublicKey(this.publicKey);\n    return new AccountAuthenticatorSingleKey(publicKey, signature);\n  }\n\n  /**\n   * Sign a transaction using Keyless.\n   * @param transaction the raw transaction\n   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key\n   */\n  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey {\n    const signature = new AnySignature(this.signTransaction(transaction));\n    const publicKey = new AnyPublicKey(this.publicKey);\n    return new AccountAuthenticatorSingleKey(publicKey, signature);\n  }\n\n  /**\n   * Waits for asyncronous proof fetching to finish.\n   * @return\n   */\n  async waitForProofFetch() {\n    if (this.proofOrPromise instanceof Promise) {\n      await this.proofOrPromise;\n    }\n  }\n\n  /**\n   * Sign the given message using Keyless.\n   * @param message in HexInput format\n   * @returns Signature\n   */\n  sign(data: HexInput): KeylessSignature {\n    const { expiryDateSecs } = this.ephemeralKeyPair;\n    if (this.isExpired()) {\n      throw new Error(\"EphemeralKeyPair is expired\");\n    }\n    if (this.proof === undefined) {\n      throw new Error(\"Proof not defined\");\n    }\n    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();\n    const ephemeralSignature = this.ephemeralKeyPair.sign(data);\n\n    return new KeylessSignature({\n      jwtHeader: base64UrlDecode(this.jwt.split(\".\")[0]),\n      ephemeralCertificate: new EphemeralCertificate(this.proof, EphemeralCertificateVariant.ZkProof),\n      expiryDateSecs,\n      ephemeralPublicKey,\n      ephemeralSignature,\n    });\n  }\n\n  /**\n   * Sign the given transaction with Keyless.\n   * Signs the transaction and proof to guard against proof malleability.\n   * @param transaction the transaction to be signed\n   * @returns KeylessSignature\n   */\n  signTransaction(transaction: AnyRawTransaction): KeylessSignature {\n    if (this.proof === undefined) {\n      throw new Error(\"Proof not found\");\n    }\n    const raw = deriveTransactionType(transaction);\n    const txnAndProof = new TransactionAndProof(raw, this.proof.proof);\n    const signMess = txnAndProof.hash();\n    return this.sign(signMess);\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    throw new Error(\"Not implemented\");\n  }\n\n  static fromBytes(bytes: Uint8Array): KeylessAccount {\n    return KeylessAccount.deserialize(new Deserializer(bytes));\n  }\n\n  static fromJWTAndProof(args: {\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    pepper: HexInput;\n    uidKey?: string;\n    proofFetchCallback?: ProofFetchCallback;\n  }): KeylessAccount {\n    const { proof, jwt, ephemeralKeyPair, pepper, proofFetchCallback } = 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      proofOrFetcher: proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      proofFetchCallback,\n    });\n  }\n}\n\n/**\n * A container class to hold a transaction and a proof.  It implements CryptoHashable which is used to create\n * the signing message for Keyless transactions.  We sign over the proof to ensure non-malleability.\n */\nexport class TransactionAndProof extends CryptoHashable {\n  /**\n   * The transaction to sign.\n   */\n  transaction: AnyRawTransactionInstance;\n\n  /**\n   * The zero knowledge proof used in signing the transaction.\n   */\n  proof?: ZkProof;\n\n  /**\n   * The domain separator prefix used when hashing.\n   */\n  domainSeparator: AptsoDomainSeparator;\n\n  constructor(transaction: AnyRawTransactionInstance, proof?: ZkProof) {\n    super();\n    this.transaction = transaction;\n    this.proof = proof;\n    this.domainSeparator = \"APTOS::TransactionAndProof\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.transaction.bcsToBytes());\n    serializer.serializeOption(this.proof);\n  }\n}\n\nexport type ProofFetchSuccess = {\n  status: \"Success\";\n};\n\nexport type ProofFetchFailure = {\n  status: \"Failed\";\n  error: string;\n};\n\nexport type ProofFetchStatus = ProofFetchSuccess | ProofFetchFailure;\n\nexport type ProofFetchCallback = (status: ProofFetchStatus) => Promise<void>;\n\nexport interface ProofFetchEvents {\n  proofFetchFinish: (status: ProofFetchStatus) => void;\n}\n"],"mappings":"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","names":["jwtDecode","EventEmitter","IssuerToJwkEndpoint","_KeylessAccount","Serializable","args","address","ephemeralKeyPair","uidKey","uidVal","aud","pepper","proofOrFetcher","proofFetchCallback","jwt","KeylessPublicKey","AccountAddress","EventEmitter","ZeroKnowledgeSig","status","pepperBytes","Hex","promise","error","serializer","deserializer","EphemeralKeyPair","proof","message","signature","AnySignature","publicKey","AnyPublicKey","AccountAuthenticatorSingleKey","transaction","data","expiryDateSecs","ephemeralPublicKey","ephemeralSignature","KeylessSignature","base64UrlDecode","EphemeralCertificate","raw","deriveTransactionType","signMess","TransactionAndProof","bytes","Deserializer","jwtPayload","jwtDecode","iss","KeylessAccount","CryptoHashable"]}

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

@@ -1,2 +0,0 @@
-import{a as c}from"./chunk-FF4L66LJ.mjs";import{a as e,b as s,c as r,d as n,e as t,g as i,h as a}from"./chunk-KSSJ3CT5.mjs";var g=class{constructor(o){this.config=o}async getLedgerInfo(){return e({aptosConfig:this.config})}async getChainId(){return(await this.getLedgerInfo()).chain_id}async getBlockByVersion(o){return s({aptosConfig:this.config,...o})}async getBlockByHeight(o){return r({aptosConfig:this.config,...o})}async view(o){return c({aptosConfig:this.config,...o})}async getChainTopUserTransactions(o){return n({aptosConfig:this.config,...o})}async queryIndexer(o){return t({aptosConfig:this.config,...o})}async getIndexerLastSuccessVersion(){return i({aptosConfig:this.config})}async getProcessorStatus(o){return a({aptosConfig:this.config,processorType:o})}};export{g as a};
-//# sourceMappingURL=chunk-5YH2YL3L.mjs.map

package/dist/esm/chunk-5YH2YL3L.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/general.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosConfig } from \"./aptosConfig\";\nimport {\n  getBlockByHeight,\n  getBlockByVersion,\n  getChainTopUserTransactions,\n  getIndexerLastSuccessVersion,\n  getLedgerInfo,\n  getProcessorStatus,\n  queryIndexer,\n} from \"../internal/general\";\nimport { view } from \"../internal/view\";\nimport {\n  AnyNumber,\n  Block,\n  GetChainTopUserTransactionsResponse,\n  GetProcessorStatusResponse,\n  GraphqlQuery,\n  LedgerInfo,\n  LedgerVersionArg,\n  MoveValue,\n} from \"../types\";\nimport { ProcessorType } from \"../utils/const\";\nimport { InputViewFunctionData } from \"../transactions\";\n\n/**\n * A class to query all `General` Aptos related queries\n */\nexport class General {\n  readonly config: AptosConfig;\n\n  constructor(config: AptosConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Queries for the Aptos ledger info\n   *\n   * @returns Aptos Ledger Info\n   *\n   * @example\n   * const ledgerInfo = await aptos.getLedgerInfo()\n   * // an example of the returned data\n   * ```\n   * {\n   * \"chain_id\": 4,\n   * \"epoch\": \"8\",\n   * \"ledger_version\": \"714\",\n   * \"oldest_ledger_version\": \"0\",\n   * \"ledger_timestamp\": \"1694695496521775\",\n   * \"node_role\": \"validator\",\n   * \"oldest_block_height\": \"0\",\n   * \"block_height\": \"359\",\n   * \"git_hash\": \"c82193f36f4e185fed9f68c4ad21f6c6dd390c6e\"\n   * }\n   * ```\n   */\n  async getLedgerInfo(): Promise<LedgerInfo> {\n    return getLedgerInfo({ aptosConfig: this.config });\n  }\n\n  /**\n   * Queries for the chain id\n   *\n   * @example\n   * const chainId = await aptos.getChainId()\n   *\n   * @returns The chain id\n   */\n  async getChainId(): Promise<number> {\n    const result = await this.getLedgerInfo();\n    return result.chain_id;\n  }\n\n  /**\n   * Queries for block by transaction version\n   *\n   * @example\n   * const block = await aptos.getBlockByVersion({ledgerVersion:5})\n   *\n   * @param args.ledgerVersion Ledger version to lookup block information for\n   * @param args.options.withTransactions If set to true, include all transactions in the block\n   *\n   * @returns Block information with optional transactions\n   */\n  async getBlockByVersion(args: {\n    ledgerVersion: AnyNumber;\n    options?: { withTransactions?: boolean };\n  }): Promise<Block> {\n    return getBlockByVersion({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Get block by block height\n   *\n   * @example\n   * const block = await aptos.getBlockByVersion({blockHeight:5})\n   *\n   * @param args.blockHeight Block height to lookup.  Starts at 0\n   * @param args.options.withTransactions If set to true, include all transactions in the block\n   *\n   * @returns Block with optional transactions\n   */\n  async getBlockByHeight(args: { blockHeight: AnyNumber; options?: { withTransactions?: boolean } }): Promise<Block> {\n    return getBlockByHeight({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for a Move view function\n   * @param args.payload Payload for the view function\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @example\n   * const data = await aptos.view({\n   *  payload: {\n   *   function: \"0x1::coin::balance\",\n   *   typeArguments: [\"0x1::aptos_coin::AptosCoin\"],\n   *   functionArguments: [accountAddress],\n   *  }\n   * })\n   *\n   * @returns an array of Move values\n   */\n  async view<T extends Array<MoveValue>>(args: {\n    payload: InputViewFunctionData;\n    options?: LedgerVersionArg;\n  }): Promise<T> {\n    return view<T>({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries top user transactions\n   *\n   * @example\n   * const topUserTransactions = await aptos.getChainTopUserTransactions({limit:5})\n   *\n   * @param args.limit The number of transactions to return\n   * @returns GetChainTopUserTransactionsResponse\n   */\n  async getChainTopUserTransactions(args: { limit: number }): Promise<GetChainTopUserTransactionsResponse> {\n    return getChainTopUserTransactions({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * A generic function for retrieving data from Aptos Indexer.\n   * For more detailed queries specification see\n   * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://api.mainnet.aptoslabs.com/v1/graphql}\n   *\n   * @example\n   * const topUserTransactions = await aptos.queryIndexer({\n   *  query: `query MyQuery {\n   *   ledger_infos {\n   *     chain_id\n   *   }}`;\n   * })\n   *\n   * @param args.query.query A GraphQL query\n   * @param args.query.variables The variables for the query\n   *\n   * @return The provided T type\n   */\n  async queryIndexer<T extends {}>(args: { query: GraphqlQuery }): Promise<T> {\n    return queryIndexer<T>({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries for the last successful indexer version\n   *\n   * This is useful to tell what ledger version the indexer is updated to, as it can be behind the full nodes.\n   *\n   * @example\n   * const version = await aptos.getIndexerLastSuccessVersion()\n   */\n  async getIndexerLastSuccessVersion(): Promise<bigint> {\n    return getIndexerLastSuccessVersion({ aptosConfig: this.config });\n  }\n\n  /**\n   * Query the processor status for a specific processor type.\n   *\n   * @example\n   * const status = await aptos.getProcessorStatus({processorType:\"account_transactions_processor\"})\n   *\n   * @param processorType The processor type to query\n   * @returns\n   */\n  async getProcessorStatus(processorType: ProcessorType): Promise<GetProcessorStatusResponse[0]> {\n    return getProcessorStatus({ aptosConfig: this.config, processorType });\n  }\n}\n"],"mappings":"4HA8BO,IAAMA,EAAN,KAAc,CAGnB,YAAYC,EAAqB,CAC/B,KAAK,OAASA,CAChB,CAwBA,MAAM,eAAqC,CACzC,OAAOC,EAAc,CAAE,YAAa,KAAK,MAAO,CAAC,CACnD,CAUA,MAAM,YAA8B,CAElC,OADe,MAAM,KAAK,cAAc,GAC1B,QAChB,CAaA,MAAM,kBAAkBC,EAGL,CACjB,OAAOC,EAAkB,CACvB,YAAa,KAAK,OAClB,GAAGD,CACL,CAAC,CACH,CAaA,MAAM,iBAAiBA,EAA4F,CACjH,OAAOE,EAAiB,CAAE,YAAa,KAAK,OAAQ,GAAGF,CAAK,CAAC,CAC/D,CAkBA,MAAM,KAAiCA,EAGxB,CACb,OAAOG,EAAQ,CAAE,YAAa,KAAK,OAAQ,GAAGH,CAAK,CAAC,CACtD,CAWA,MAAM,4BAA4BA,EAAuE,CACvG,OAAOI,EAA4B,CACjC,YAAa,KAAK,OAClB,GAAGJ,CACL,CAAC,CACH,CAoBA,MAAM,aAA2BA,EAA2C,CAC1E,OAAOK,EAAgB,CACrB,YAAa,KAAK,OAClB,GAAGL,CACL,CAAC,CACH,CAUA,MAAM,8BAAgD,CACpD,OAAOM,EAA6B,CAAE,YAAa,KAAK,MAAO,CAAC,CAClE,CAWA,MAAM,mBAAmBC,EAAsE,CAC7F,OAAOC,EAAmB,CAAE,YAAa,KAAK,OAAQ,cAAAD,CAAc,CAAC,CACvE,CACF","names":["General","config","getLedgerInfo","args","getBlockByVersion","getBlockByHeight","view","getChainTopUserTransactions","queryIndexer","getIndexerLastSuccessVersion","processorType","getProcessorStatus"]}

package/dist/esm/chunk-FLALKQIK.mjs

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

package/dist/esm/chunk-KCRCX6BL.mjs

@@ -1,2 +0,0 @@
-import{b as c}from"./chunk-4TDMJQOJ.mjs";import{a as l,l as P,m as d,n as h,o as m}from"./chunk-T4HO5JMQ.mjs";import{b as y}from"./chunk-L5CPAOUM.mjs";import{b as g}from"./chunk-F3ZVWLDH.mjs";import{a as x}from"./chunk-AH44UPM4.mjs";import{b as u}from"./chunk-JOXU5RWH.mjs";import{e as K,f as C}from"./chunk-CVCM46UN.mjs";import{b as i}from"./chunk-AOCNYMMX.mjs";async function L(e){let{aptosConfig:r}=e;return x(async()=>{let o=await _(e),t=await w(e);return m.create(t,Number(o.max_exp_horizon_secs))},`keyless-configuration-${r.network}`,1e3*60*5)()}async function _(e){let{aptosConfig:r,options:o}=e,t="0x1::keyless_account::Configuration",{data:n}=await u({aptosConfig:r,originMethod:"getKeylessConfiguration",path:`accounts/${g.from("0x1").toString()}/resource/${t}`,params:{ledger_version:o?.ledgerVersion}});return n.data}async function w(e){let{aptosConfig:r,options:o}=e,t="0x1::keyless_account::Groth16VerificationKey",{data:n}=await u({aptosConfig:r,originMethod:"getGroth16VerificationKey",path:`accounts/${g.from("0x1").toString()}/resource/${t}`,params:{ledger_version:o?.ledgerVersion}});return n.data}async function b(e){let{aptosConfig:r,jwt:o,ephemeralKeyPair:t,uidKey:n,derivationPath:s}=e,p={jwt_b64:o,epk:t.getPublicKey().bcsToHex().toStringWithoutPrefix(),exp_date_secs:t.expiryDateSecs,epk_blinder:i.fromHexInput(t.blinder).toStringWithoutPrefix(),uid_key:n||"sub",derivation_path:s},{data:a}=await K({aptosConfig:r,path:"fetch",body:p,originMethod:"getPepper",overrides:{WITH_CREDENTIALS:!1}});return i.fromHexInput(a.pepper).toUint8Array()}async function R(e){let{aptosConfig:r,jwt:o,ephemeralKeyPair:t,pepper:n,uidKey:s}=e,p={jwt_b64:o,epk:t.getPublicKey().bcsToHex().toStringWithoutPrefix(),epk_blinder:i.fromHexInput(t.blinder).toStringWithoutPrefix(),exp_date_secs:t.expiryDateSecs,exp_horizon_secs:l,pepper:i.fromHexInput(n).toStringWithoutPrefix(),uid_key:s||"sub"};console.log(JSON.stringify(p));let{data:a}=await C({aptosConfig:r,path:"prove",body:p,originMethod:"getProof",overrides:{WITH_CREDENTIALS:!1}}),f=a.proof,A=new P({a:f.a,b:f.b,c:f.c});return new h({proof:new d(A,0),trainingWheelsSignature:y.fromHex(a.training_wheels_signature)})}async function N(e){let{proofFetchCallback:r}=e,{pepper:o}=e;if(o===void 0?o=await b(e):o=i.fromHexInput(o).toUint8Array(),o.length!==c.PEPPER_LENGTH)throw new Error(`Pepper needs to be ${c.PEPPER_LENGTH} bytes`);let t=R({...e,pepper:o}),n=r?t:await t;return c.fromJWTAndProof({...e,proof:n,pepper:o,proofFetchCallback:r})}export{L as a,b,R as c,N as d};
-//# sourceMappingURL=chunk-KCRCX6BL.mjs.map

package/dist/esm/chunk-KCRCX6BL.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/keyless}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * keyless namespace and without having a dependency cycle error.\n */\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { getAptosFullNode, postAptosPepperService, postAptosProvingService } from \"../client\";\nimport {\n  AccountAddress,\n  EPK_HORIZON_SECS,\n  EphemeralSignature,\n  Groth16Zkp,\n  Hex,\n  KeylessConfiguration,\n  ZeroKnowledgeSig,\n  ZkProof,\n} from \"../core\";\nimport { HexInput, LedgerVersionArg, MoveResource, ZkpVariant } from \"../types\";\nimport { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from \"../account\";\nimport {\n  Groth16VerificationKeyResponse,\n  KeylessConfigurationResponse,\n  PepperFetchRequest,\n  PepperFetchResponse,\n  ProverRequest,\n  ProverResponse,\n} from \"../types/keyless\";\nimport { memoizeAsync } from \"../utils/memoize\";\n\nexport async function getKeylessConfig(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<KeylessConfiguration> {\n  const { aptosConfig } = args;\n  return memoizeAsync(\n    async () => {\n      const config = await getKeylessConfiguration(args);\n      const vk = await getGroth16VerificationKey(args);\n      return KeylessConfiguration.create(vk, Number(config.max_exp_horizon_secs));\n    },\n    `keyless-configuration-${aptosConfig.network}`,\n    1000 * 60 * 5, // 5 minutes\n  )();\n}\n\nasync function getKeylessConfiguration(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<KeylessConfigurationResponse> {\n  const { aptosConfig, options } = args;\n  const resourceType = \"0x1::keyless_account::Configuration\";\n  const { data } = await getAptosFullNode<{}, MoveResource<KeylessConfigurationResponse>>({\n    aptosConfig,\n    originMethod: \"getKeylessConfiguration\",\n    path: `accounts/${AccountAddress.from(\"0x1\").toString()}/resource/${resourceType}`,\n    params: { ledger_version: options?.ledgerVersion },\n  });\n\n  return data.data;\n}\n\nasync function getGroth16VerificationKey(args: {\n  aptosConfig: AptosConfig;\n  options?: LedgerVersionArg;\n}): Promise<Groth16VerificationKeyResponse> {\n  const { aptosConfig, options } = args;\n  const resourceType = \"0x1::keyless_account::Groth16VerificationKey\";\n  const { data } = await getAptosFullNode<{}, MoveResource<Groth16VerificationKeyResponse>>({\n    aptosConfig,\n    originMethod: \"getGroth16VerificationKey\",\n    path: `accounts/${AccountAddress.from(\"0x1\").toString()}/resource/${resourceType}`,\n    params: { ledger_version: options?.ledgerVersion },\n  });\n\n  return data.data;\n}\n\nexport async function getPepper(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  derivationPath?: string;\n}): Promise<Uint8Array> {\n  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, derivationPath } = args;\n\n  const body = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),\n    exp_date_secs: ephemeralKeyPair.expiryDateSecs,\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    uid_key: uidKey || \"sub\",\n    derivation_path: derivationPath,\n  };\n  const { data } = await postAptosPepperService<PepperFetchRequest, PepperFetchResponse>({\n    aptosConfig,\n    path: \"fetch\",\n    body,\n    originMethod: \"getPepper\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n  return Hex.fromHexInput(data.pepper).toUint8Array();\n}\n\nexport async function getProof(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  pepper: HexInput;\n  uidKey?: string;\n}): Promise<ZeroKnowledgeSig> {\n  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey } = args;\n  const json = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    exp_date_secs: ephemeralKeyPair.expiryDateSecs,\n    exp_horizon_secs: EPK_HORIZON_SECS,\n    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),\n    uid_key: uidKey || \"sub\",\n  };\n\n  console.log(JSON.stringify(json))\n\n  const { data } = await postAptosProvingService<ProverRequest, 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 groth16Zkp = new Groth16Zkp({\n    a: proofPoints.a,\n    b: proofPoints.b,\n    c: proofPoints.c,\n  });\n\n  const signedProof = new ZeroKnowledgeSig({\n    proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),\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  proofFetchCallback?: ProofFetchCallback;\n}): Promise<KeylessAccount> {\n  const { proofFetchCallback } = args;\n  let { pepper } = args;\n  if (pepper === undefined) {\n    pepper = await getPepper(args);\n  } else {\n    pepper = Hex.fromHexInput(pepper).toUint8Array();\n  }\n\n  if (pepper.length !== KeylessAccount.PEPPER_LENGTH) {\n    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);\n  }\n\n  const proofPromise = getProof({ ...args, pepper });\n  const proof = proofFetchCallback ? proofPromise : await proofPromise;\n\n  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proof, pepper, proofFetchCallback });\n\n  return keylessAccount;\n}\n"],"mappings":"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","names":["getKeylessConfig","args","aptosConfig","memoizeAsync","config","getKeylessConfiguration","vk","getGroth16VerificationKey","KeylessConfiguration","options","resourceType","data","getAptosFullNode","AccountAddress","getPepper","jwt","ephemeralKeyPair","uidKey","derivationPath","body","Hex","postAptosPepperService","getProof","pepper","json","EPK_HORIZON_SECS","postAptosProvingService","proofPoints","groth16Zkp","Groth16Zkp","ZeroKnowledgeSig","ZkProof","EphemeralSignature","deriveKeylessAccount","proofFetchCallback","KeylessAccount","proofPromise","proof"]}

package/dist/esm/chunk-KNMQU2TA.mjs

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/keyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from \"../account\";\nimport { KeylessConfiguration } from \"../core\";\nimport { deriveKeylessAccount, getKeylessConfig, getPepper } from \"../internal/keyless\";\nimport { HexInput, LedgerVersionArg } from \"../types\";\nimport { AptosConfig } from \"./aptosConfig\";\n\n/**\n * A class to query all `Keyless` related queries on Aptos.\n */\nexport class Keyless {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Gets the parameters of how Keyless Accounts are configured on chain.\n   *\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   * @returns KeylessConfiguration\n   */\n  async getKeylessConfig(options?: LedgerVersionArg): Promise<KeylessConfiguration> {\n    return getKeylessConfig({ aptosConfig: this.config, options });\n  }\n\n  /**\n   * Fetches the pepper from the Aptos pepper service API.\n   *\n   * @param args.jwt JWT token\n   * @param args.ephemeralKeyPair the EphemeralKeyPair used to generate the nonce in the JWT token\n   * @returns The pepper which is a Uint8Array of length 31.\n   */\n  async getPepper(args: { jwt: string; ephemeralKeyPair: EphemeralKeyPair }): Promise<Uint8Array> {\n    return getPepper({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Fetches the pepper from the Aptos pepper service API.\n   *\n   * @param args.jwt JWT token\n   * @param args.ephemeralKeyPair the EphemeralKeyPair used to generate the nonce in the JWT token\n   * @param args.uidKey a key in the JWT token to use to set the uidVal in the IdCommitment\n   * @param args.pepper the pepper\n   * @param args.proofFetchCallback a callback function that if set, the fetch of the proof will be done asyncronously. Once\n   * if finishes the callback function will be called.\n   * @returns A KeylessAccount that can be used to sign transactions\n   */\n  async deriveKeylessAccount(args: {\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    uidKey?: string;\n    pepper?: HexInput;\n    proofFetchCallback?: ProofFetchCallback;\n  }): Promise<KeylessAccount> {\n    return deriveKeylessAccount({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"uDAYO,IAAMA,EAAN,KAAc,CACnB,YAAqBC,EAAqB,CAArB,YAAAA,CAAsB,CAQ3C,MAAM,iBAAiBC,EAA2D,CAChF,OAAOC,EAAiB,CAAE,YAAa,KAAK,OAAQ,QAAAD,CAAQ,CAAC,CAC/D,CASA,MAAM,UAAUE,EAAgF,CAC9F,OAAOC,EAAU,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CACxD,CAaA,MAAM,qBAAqBA,EAMC,CAC1B,OAAOE,EAAqB,CAAE,YAAa,KAAK,OAAQ,GAAGF,CAAK,CAAC,CACnE,CACF","names":["Keyless","config","options","getKeylessConfig","args","getPepper","deriveKeylessAccount"]}

package/dist/esm/chunk-KSSJ3CT5.mjs

@@ -1,2 +0,0 @@
-import{m as p,v as a}from"./chunk-S3EDNXZE.mjs";import{b as n}from"./chunk-JOXU5RWH.mjs";import{c}from"./chunk-CVCM46UN.mjs";async function h(o){let{aptosConfig:t}=o,{data:s}=await n({aptosConfig:t,originMethod:"getLedgerInfo",path:""});return s}async function d(o){let{aptosConfig:t,ledgerVersion:s,options:e}=o,{data:r}=await n({aptosConfig:t,originMethod:"getBlockByVersion",path:`blocks/by_version/${s}`,params:{with_transactions:e?.withTransactions}});return r}async function C(o){let{aptosConfig:t,blockHeight:s,options:e}=o,{data:r}=await n({aptosConfig:t,originMethod:"getBlockByHeight",path:`blocks/by_height/${s}`,params:{with_transactions:e?.withTransactions}});return r}async function l(o){let{aptosConfig:t,limit:s}=o;return(await i({aptosConfig:t,query:{query:p,variables:{limit:s}},originMethod:"getChainTopUserTransactions"})).user_transactions}async function i(o){let{aptosConfig:t,query:s,originMethod:e}=o,{data:r}=await c({aptosConfig:t,originMethod:e??"queryIndexer",path:"",body:s,overrides:{WITH_CREDENTIALS:!1}});return r}async function g(o){let{aptosConfig:t}=o;return(await i({aptosConfig:t,query:{query:a},originMethod:"getProcessorStatuses"})).processor_status}async function m(o){let t=await g({aptosConfig:o.aptosConfig});return BigInt(t[0].last_success_version)}async function T(o){let{aptosConfig:t,processorType:s}=o;return(await i({aptosConfig:t,query:{query:a,variables:{where_condition:{processor:{_eq:s}}}},originMethod:"getProcessorStatus"})).processor_status[0]}export{h as a,d as b,C as c,l as d,i as e,g as f,m as g,T as h};
-//# sourceMappingURL=chunk-KSSJ3CT5.mjs.map