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

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";
@@ -37,7 +38,7 @@ export class KeylessPublicKey extends AccountPublicKey {
 
   /**
    * A value representing a cryptographic commitment to a user identity.
-   * 
+   *
    * It is calculated from the aud, uidKey, uidVal, pepper.
    */
   readonly idCommitment: Uint8Array;
@@ -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,
       ),
@@ -322,7 +336,7 @@ class G1Bytes extends Serializable {
   }
 
   serialize(serializer: Serializer): void {
-  serializer.serializeFixedBytes(this.data);
+    serializer.serializeFixedBytes(this.data);
   }
 
   static deserialize(deserializer: Deserializer): G1Bytes {
@@ -343,7 +357,7 @@ class G2Bytes extends Serializable {
   }
 
   serialize(serializer: Serializer): void {
-  serializer.serializeFixedBytes(this.data);
+    serializer.serializeFixedBytes(this.data);
   }
 
   static deserialize(deserializer: Deserializer): G2Bytes {
@@ -374,9 +388,9 @@ export class Groth16Zkp extends Proof {
   constructor(args: { a: HexInput; b: HexInput; c: HexInput }) {
     super();
     const { a, b, c } = args;
-    this.a = new G1Bytes(a)
-    this.b = new G2Bytes(b)
-    this.c = new G1Bytes(c)
+    this.a = new G1Bytes(a);
+    this.b = new G2Bytes(b);
+    this.c = new G1Bytes(c);
   }
 
   serialize(serializer: Serializer): void {
@@ -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) {
@@ -534,56 +551,72 @@ export class KeylessConfiguration {
   }
 
   static create(res: Groth16VerificationKeyResponse, maxExpHorizonSecs: number): KeylessConfiguration {
-    return new KeylessConfiguration(new Groth16VerificationKey({
+    return new KeylessConfiguration(
+      new Groth16VerificationKey({
+        alphaG1: res.alpha_g1,
+        betaG2: res.beta_g2,
+        deltaG2: res.delta_g2,
+        gammaAbcG1: res.gamma_abc_g1,
+        gammaG2: res.gamma_g2,
+      }),
+      maxExpHorizonSecs,
+    );
+  }
+}
+
+/**
+ * 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: {
+    alphaG1: HexInput;
+    betaG2: HexInput;
+    deltaG2: HexInput;
+    gammaAbcG1: [HexInput, HexInput];
+    gammaG2: HexInput;
+  }) {
+    const { alphaG1, betaG2, deltaG2, gammaAbcG1, gammaG2 } = args;
+    this.alphaG1 = new G1Bytes(alphaG1);
+    this.betaG2 = new G2Bytes(betaG2);
+    this.deltaG2 = new G2Bytes(deltaG2);
+    this.gammaAbcG1 = [new G1Bytes(gammaAbcG1[0]), new G1Bytes(gammaAbcG1[1])];
+    this.gammaG2 = new G2Bytes(gammaG2);
+  }
+
+  static fromGroth16VerificationKeyResponse(res: Groth16VerificationKeyResponse): Groth16VerificationKey {
+    return new Groth16VerificationKey({
       alphaG1: res.alpha_g1,
       betaG2: res.beta_g2,
       deltaG2: res.delta_g2,
       gammaAbcG1: res.gamma_abc_g1,
-      gammaG2: res.gamma_g2
-    }), maxExpHorizonSecs)
+      gammaG2: res.gamma_g2,
+    });
   }
-
 }
-  
-  class Groth16VerificationKey {
-    readonly alphaG1: G1Bytes;
-
-    readonly betaG2: G2Bytes;
-
-    readonly deltaG2: G2Bytes;
-
-    readonly gammaAbcG1: G1Bytes[];
-
-    readonly gammaG2: G2Bytes;
-  
-    constructor(args: {
-      alphaG1: HexInput;
-      betaG2: HexInput;
-      deltaG2: HexInput;
-      gammaAbcG1: [HexInput, HexInput];
-      gammaG2: HexInput;
-    }) {
-      const {
-        alphaG1,
-        betaG2,
-        deltaG2,
-        gammaAbcG1,
-        gammaG2,
-      } = args;
-      this.alphaG1 = new G1Bytes(alphaG1)
-      this.betaG2 = new G2Bytes(betaG2)
-      this.deltaG2 = new G2Bytes(deltaG2)
-      this.gammaAbcG1 = [new G1Bytes(gammaAbcG1[0]), new G1Bytes(gammaAbcG1[1])]
-      this.gammaG2 =new G2Bytes(gammaG2)
-    }
-
-    static fromGroth16VerificationKeyResponse(res: Groth16VerificationKeyResponse): Groth16VerificationKey {
-      return new Groth16VerificationKey({
-        alphaG1: res.alpha_g1,
-        betaG2: res.beta_g2,
-        deltaG2: res.delta_g2,
-        gammaAbcG1: res.gamma_abc_g1,
-        gammaG2: res.gamma_g2
-      })
-    }
-  }

package/src/core/crypto/poseidon.ts

@@ -43,7 +43,7 @@ const MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALA
 
 /**
  * Hashes a string to a field element via poseidon
- * 
+ *
  * @returns bigint result of the hash
  */
 export function hashStrToField(str: string, maxSizeBytes: number): bigint {
@@ -129,14 +129,16 @@ function padUint8ArrayWithZeros(inputArray: Uint8Array, paddedSize: number): Uin
 
 /**
  * Hashes up to 16 scalar elements via the poseidon hashing algorithm.
- * 
+ *
  * Each element must be scalar fields of the BN254 elliptic curve group.
  *
  * @returns bigint result of the hash
  */
 export function poseidonHash(inputs: (number | bigint | string)[]): bigint {
   if (inputs.length > numInputsToPoseidonFunc.length) {
-    throw new Error(`Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`);
+    throw new Error(
+      `Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`,
+    );
   }
   return numInputsToPoseidonFunc[inputs.length - 1](inputs);
 }

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,15 +130,16 @@ 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,
   };
 
   const { data } = await postAptosProvingService<ProverRequest, ProverResponse>({
@@ -142,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;
 }
@@ -169,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/internal/transactionSubmission.ts

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

package/src/types/keyless.ts

@@ -1,11 +1,11 @@
 export type ProverRequest = {
-  jwt_b64: string,
-  epk: string,
-  exp_date_secs: number,
-  exp_horizon_secs: number,
-  epk_blinder: string,
-  uid_key: string,
-  pepper: string,
+  jwt_b64: string;
+  epk: string;
+  exp_date_secs: number;
+  exp_horizon_secs: number;
+  epk_blinder: string;
+  uid_key: string;
+  pepper: string;
 };
 export type ProverResponse = {
   proof: { a: string; b: string; c: string };
@@ -13,25 +13,25 @@ export type ProverResponse = {
   training_wheels_signature: string;
 };
 export type PepperFetchRequest = {
-  jwt_b64: number,
-  epk: string,
-  exp_date_secs: number,
-  epk_blinder: string,
-  uid_key: string,
-  derivation_path: string,
+  jwt_b64: number;
+  epk: string;
+  exp_date_secs: number;
+  epk_blinder: string;
+  uid_key: string;
+  derivation_path: string;
 };
 export type PepperFetchResponse = { signature: string; pepper: string; address: string };
 
 export type KeylessConfigurationResponse = {
-  max_commited_epk_bytes: number,
-  max_exp_horizon_secs: string,
-  max_extra_field_bytes: number,
-  max_iss_val_bytes: number,
-  max_jwt_header_b64_bytes: number,
-  max_signatures_per_txn: number,
-  override_aud_vals: string[],
-  training_wheels_pubkey: { vec: string[] }
-}
+  max_commited_epk_bytes: number;
+  max_exp_horizon_secs: string;
+  max_extra_field_bytes: number;
+  max_iss_val_bytes: number;
+  max_jwt_header_b64_bytes: number;
+  max_signatures_per_txn: number;
+  override_aud_vals: string[];
+  training_wheels_pubkey: { vec: string[] };
+};
 
 export type Groth16VerificationKeyResponse = {
   alpha_g1: string;

package/src/utils/helpers.ts

@@ -13,7 +13,6 @@ export async function sleep(timeMs: number): Promise<null> {
   });
 }
 
-
 export function currentTimeInSeconds(): number {
   return Math.floor(new Date().getTime() / 1000);
 }
@@ -27,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.1";
+export const VERSION = "1.16.0-zeta.3";

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

@@ -1,2 +0,0 @@
-import{a as g,f as d,g as b,i as S}from"./chunk-RAHMGSBW.mjs";import{a as C}from"./chunk-3J53BCEQ.mjs";import{b as f}from"./chunk-WSVJNBSJ.mjs";import{a as P}from"./chunk-PG7KSUMN.mjs";import{a as w}from"./chunk-SSDWEOF7.mjs";import{d as I}from"./chunk-MEOBWD6V.mjs";import{c as l}from"./chunk-OZ3GSAFK.mjs";import{c as y,m as s}from"./chunk-VBODXPT3.mjs";import{a as T}from"./chunk-XQ7I34AL.mjs";import{b as p}from"./chunk-WHSN42R2.mjs";import{a as r}from"./chunk-GS5Z3HO7.mjs";import{b as A}from"./chunk-ZV5P2GSJ.mjs";async function h(t){let a=await K(t);return D(t,a)}async function K(t){let{aptosConfig:a,data:n}=t,e,o;return"bytecode"in n?o=await g(n):"multisigAddress"in n?(e={aptosConfig:a,multisigAddress:n.multisigAddress,function:n.function,functionArguments:n.functionArguments,typeArguments:n.typeArguments,abi:n.abi},o=await g(e)):(e={aptosConfig:a,function:n.function,functionArguments:n.functionArguments,typeArguments:n.typeArguments,abi:n.abi},o=await g(e)),o}async function D(t,a){let{aptosConfig:n,sender:e,options:o}=t,i;if(G(t)&&(i=p.ZERO.toString()),U(t)){let{secondarySignerAddresses:c}=t;return d({aptosConfig:n,sender:e,payload:a,options:o,secondarySignerAddresses:c,feePayerAddress:i})}return d({aptosConfig:n,sender:e,payload:a,options:o,feePayerAddress:i})}function G(t){return t.withFeePayer===!0}function U(t){return"secondarySignerAddresses"in t}function nn(t){let{transaction:a}=t;return l(a)}function _(t){let{signer:a,transaction:n}=t;return a.signTransactionWithAuthenticator(n)}async function tn(t){let{aptosConfig:a,transaction:n,signerPublicKey:e,secondarySignersPublicKeys:o,feePayerPublicKey:i,options:c}=t,u=b({transaction:n,signerPublicKey:e,secondarySignersPublicKeys:o,feePayerPublicKey:i,options:c}),{data:m}=await f({aptosConfig:a,body:u,path:"transactions/simulate",params:{estimate_gas_unit_price:t.options?.estimateGasUnitPrice??!1,estimate_max_gas_amount:t.options?.estimateMaxGasAmount??!1,estimate_prioritized_gas_unit_price:t.options?.estimatePrioritizedGasUnitPrice??!1},originMethod:"simulateTransaction",contentType:"application/x.aptos.signed_transaction+bcs"});return m}async function B(t){let{aptosConfig:a}=t,n=S({...t}),{data:e}=await f({aptosConfig:a,body:n,path:"transactions",originMethod:"submitTransaction",contentType:"application/x.aptos.signed_transaction+bcs"});return e}async function M(t){let{aptosConfig:a,signer:n,transaction:e}=t;(n instanceof I||n instanceof w)&&await n.waitForProofFetch();let o=_({signer:n,transaction:e});return B({aptosConfig:a,transaction:e,senderAuthenticator:o})}var N={typeParameters:[],parameters:[s.u8(),new s(s.u8())]};async function an(t){let{aptosConfig:a,account:n,metadataBytes:e,moduleBytecode:o,options:i}=t,c=o.map(u=>r.U8(u));return h({aptosConfig:a,sender:p.from(n),data:{function:"0x1::code::publish_package_txn",functionArguments:[r.U8(e),new r(c)],abi:N},options:i})}var F={typeParameters:[],parameters:[new y,s.u8(),new y,s.u8(),s.u8(),s.u8()]};async function en(t){let{aptosConfig:a,fromAccount:n,toNewPrivateKey:e}=t,o=await C({aptosConfig:a,accountAddress:n.accountAddress}),i=P.fromPrivateKey({privateKey:e,legacy:!0}),u=new T({sequenceNumber:BigInt(o.sequence_number),originator:n.accountAddress,currentAuthKey:p.from(o.authentication_key),newPublicKey:i.publicKey}).bcsToBytes(),m=n.sign(u),R=i.sign(u),x=await h({aptosConfig:a,sender:n.accountAddress,data:{function:"0x1::account::rotate_authentication_key",functionArguments:[new A(n.signingScheme),r.U8(n.publicKey.toUint8Array()),new A(i.signingScheme),r.U8(i.publicKey.toUint8Array()),r.U8(m.toUint8Array()),r.U8(R.toUint8Array())],abi:F}});return M({aptosConfig:a,signer:n,transaction:x})}export{h as a,K as b,D as c,nn as d,_ as e,tn as f,B as g,M as h,an as i,en as j};
-//# sourceMappingURL=chunk-4RXGVY2H.mjs.map