@aptos-labs/ts-sdk 1.27.1-zeta.0 → 1.28.0

package/src/internal/account.ts

@@ -409,26 +409,27 @@ export async function getAccountCoinAmount(args: {
   faMetadataAddress?: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, accountAddress, coinType, faMetadataAddress } = args;
-  let coinAssetType: string | undefined;
+
+  let coinAssetType: string | undefined = coinType;
   let faAddress: string;
 
   if (coinType !== undefined && faMetadataAddress !== undefined) {
     faAddress = AccountAddress.from(faMetadataAddress).toStringLong();
   } else if (coinType !== undefined && faMetadataAddress === undefined) {
-    coinAssetType = coinType;
     // TODO Move to a separate function as defined in the AIP for coin migration
-    if (args.coinType === APTOS_COIN) {
+    if (coinType === APTOS_COIN) {
       faAddress = AccountAddress.A.toStringLong();
     } else {
       faAddress = createObjectAddress(AccountAddress.A, coinType).toStringLong();
     }
   } else if (coinType === undefined && faMetadataAddress !== undefined) {
-    // TODO: add a view function lookup for non-APT migrated coins
     const addr = AccountAddress.from(faMetadataAddress);
     faAddress = addr.toStringLong();
     if (addr === AccountAddress.A) {
       coinAssetType = APTOS_COIN;
     }
+    // The paired CoinType should be populated outside of this function in another
+    // async call. We cannot do this internally due to dependency cycles issue.
   } else {
     throw new Error("Either coinType, fungibleAssetAddress, or both must be provided");
   }
@@ -436,7 +437,7 @@ export async function getAccountCoinAmount(args: {
 
   // Search by fungible asset address, unless it has a coin it migrated from
   let where: any = { asset_type: { _eq: faAddress } };
-  if (coinType !== undefined) {
+  if (coinAssetType !== undefined) {
     where = { asset_type: { _in: [coinAssetType, faAddress] } };
   }
 

package/src/internal/event.ts

@@ -31,9 +31,16 @@ export async function getModuleEventsByEventType(args: {
   const { aptosConfig, eventType, options } = args;
 
   const whereCondition: EventsBoolExp = {
-    account_address: { _eq: "0x0000000000000000000000000000000000000000000000000000000000000000" },
-    creation_number: { _eq: "0" },
-    sequence_number: { _eq: "0" },
+    _or: [
+      // EventHandle events
+      { account_address: { _eq: eventType.split("::")[0] } },
+      // Module events
+      {
+        account_address: { _eq: "0x0000000000000000000000000000000000000000000000000000000000000000" },
+        sequence_number: { _eq: 0 },
+        creation_number: { _eq: 0 },
+      },
+    ],
     indexed_type: { _eq: eventType },
   };
 

package/src/internal/keyless.ts

@@ -10,7 +10,6 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { postAptosPepperService, postAptosProvingService } from "../client";
 import {
-  AccountAddressInput,
   EphemeralSignature,
   Groth16Zkp,
   Hex,
@@ -24,8 +23,6 @@ import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account
 import { PepperFetchRequest, PepperFetchResponse, ProverRequest, ProverResponse } from "../types/keyless";
 import { nowInSeconds } from "../utils/helpers";
 import { lookupOriginalAccountAddress } from "./account";
-import { FederatedKeylessPublicKey } from "../core/crypto/federatedKeyless";
-import { FederatedKeylessAccount } from "../account/FederatedKeylessAccount";
 
 export async function getPepper(args: {
   aptosConfig: AptosConfig;
@@ -126,33 +123,7 @@ export async function deriveKeylessAccount(args: {
     authenticationKey: publicKey.authKey().derivedAddress(),
   });
 
-  return KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback });
-}
-
-export async function deriveFederatedKeylessAccount(args: {
-  aptosConfig: AptosConfig;
-  jwt: string;
-  ephemeralKeyPair: EphemeralKeyPair;
-  jwkAddress: AccountAddressInput;
-  uidKey?: string;
-  pepper?: HexInput;
-  proofFetchCallback?: ProofFetchCallback;
-}): Promise<FederatedKeylessAccount> {
-  const { aptosConfig, jwt, jwkAddress, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;
-  const proofPromise = getProof({ ...args, pepper });
-  // If a callback is provided, pass in the proof as a promise to KeylessAccount.create.  This will make the proof be fetched in the
-  // background and the callback will handle the outcome of the fetch.  This allows the developer to not have to block on the proof fetch
-  // allowing for faster rendering of UX.
-  //
-  // If no callback is provided, the just await the proof fetch and continue syncronously.
-  const proof = proofFetchCallback ? proofPromise : await proofPromise;
-
-  // Look up the original address to handle key rotations
-  const publicKey = FederatedKeylessPublicKey.fromJwtAndPepper({ jwt, pepper, jwkAddress, uidKey });
-  const address = await lookupOriginalAccountAddress({
-    aptosConfig,
-    authenticationKey: publicKey.authKey().derivedAddress(),
-  });
+  const keylessAccount = KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback });
 
-  return FederatedKeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback });
+  return keylessAccount;
 }

package/src/transactions/instances/transactionPayload.ts

@@ -7,7 +7,7 @@ import { Deserializer } from "../../bcs/deserializer";
 import { Serializable, Serializer } from "../../bcs/serializer";
 import { EntryFunctionBytes } from "../../bcs/serializable/entryFunctionBytes";
 import { Bool, U128, U16, U256, U32, U64, U8 } from "../../bcs/serializable/movePrimitives";
-import { MoveVector } from "../../bcs/serializable/moveStructs";
+import { MoveVector, Serialized } from "../../bcs/serializable/moveStructs";
 import { AccountAddress } from "../../core";
 import { Identifier } from "./identifier";
 import { ModuleId } from "./moduleId";
@@ -40,6 +40,8 @@ export function deserializeFromScriptArgument(deserializer: Deserializer): Trans
       return U32.deserialize(deserializer);
     case ScriptTransactionArgumentVariants.U256:
       return U256.deserialize(deserializer);
+    case ScriptTransactionArgumentVariants.Serialized:
+      return Serialized.deserialize(deserializer);
     default:
       throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`);
   }

package/src/transactions/types.ts

@@ -20,6 +20,7 @@ import { TypeTag } from "./typeTag";
 import { AccountAuthenticator } from "./authenticator/account";
 import { SimpleTransaction } from "./instances/simpleTransaction";
 import { MultiAgentTransaction } from "./instances/multiAgentTransaction";
+import { Serialized } from "../bcs";
 
 /**
  * Entry function arguments to be used when building a raw transaction using remote ABI
@@ -64,9 +65,10 @@ export type ScriptFunctionArgumentTypes =
   | U128
   | U256
   | AccountAddress
-  | MoveVector<U8>
+  | MoveVector<ScriptFunctionArgumentTypes>
   | MoveString
-  | FixedBytes;
+  | FixedBytes
+  | Serialized;
 
 /**
  * TypeArgument inputs for Entry functions, view functions, and scripts

package/src/types/index.ts

@@ -61,6 +61,7 @@ export enum ScriptTransactionArgumentVariants {
   U16 = 6,
   U32 = 7,
   U256 = 8,
+  Serialized = 9,
 }
 
 /**
@@ -109,7 +110,6 @@ export enum AnyPublicKeyVariant {
   Ed25519 = 0,
   Secp256k1 = 1,
   Keyless = 3,
-  FederatedKeyless = 4,
 }
 
 export enum AnySignatureVariant {

package/src/utils/apiEndpoints.ts

@@ -25,19 +25,17 @@ export const NetworkToFaucetAPI: Record<string, string> = {
 export const NetworkToPepperAPI: Record<string, string> = {
   mainnet: "https://api.mainnet.aptoslabs.com/keyless/pepper/v0",
   testnet: "https://api.testnet.aptoslabs.com/keyless/pepper/v0",
-  devnet: "https://pepper.keyless.devnet.aptoslabs.com/v0",
+  devnet: "https://api.devnet.aptoslabs.com/keyless/pepper/v0",
   // Use the devnet service for local environment
-  local: "https://pepper.keyless.devnet.aptoslabs.com/v0",
+  local: "https://api.devnet.aptoslabs.com/keyless/pepper/v0",
 };
 
-
-
 export const NetworkToProverAPI: Record<string, string> = {
   mainnet: "https://api.mainnet.aptoslabs.com/keyless/prover/v0",
   testnet: "https://api.testnet.aptoslabs.com/keyless/prover/v0",
-  devnet: "https://prover.keyless.devnet.aptoslabs.com/v0",
+  devnet: "https://api.devnet.aptoslabs.com/keyless/prover/v0",
   // Use the devnet service for local environment
-  local: "https://prover.keyless.devnet.aptoslabs.com/v0",
+  local: "https://api.devnet.aptoslabs.com/keyless/prover/v0",
 };
 
 export enum Network {

package/src/utils/const.ts

@@ -44,6 +44,7 @@ export const DEFAULT_TXN_TIMEOUT_SEC = 20;
  * The default gas currency for the network.
  */
 export const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
+export const APTOS_FA = "0x000000000000000000000000000000000000000000000000000000000000000a";
 
 export const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
 export const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";

package/src/utils/helpers.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { decode } from "js-base64";
+import { MoveStructId } from "../types";
 
 /**
  * Sleep the current thread for the given amount of time
@@ -58,3 +59,72 @@ export const convertAmountFromHumanReadableToOnChain = (value: number, decimal:
  * @returns The value is smallest units
  */
 export const convertAmountFromOnChainToHumanReadable = (value: number, decimal: number) => value / 10 ** decimal;
+
+/**
+ * Convert a hex string to an ascii string with the `0x` prefix.
+ *
+ * `0x6170746f735f636f696e` --> `aptos_coin`
+ *
+ * @param hex The hex string to convert (e.g. `0x6170746f735f636f696e`)
+ * @returns The ascii string
+ */
+const hexToAscii = (hex: string) => {
+  let str = "";
+  for (let n = 2; n < hex.length; n += 2) {
+    str += String.fromCharCode(parseInt(hex.substring(n, n + 2), 16));
+  }
+  return str;
+};
+
+/**
+ * Convert an encoded struct to a MoveStructId.
+ *
+ * @example
+ * const structObj = {
+ *   account_address: "0x1",
+ *   module_name: "0x6170746f735f636f696e",
+ *   struct_name: "0x4170746f73436f696e",
+ * };
+ * // structId is "0x1::aptos_coin::AptosCoin"
+ * const structId = parseEncodedStruct(structObj);
+ *
+ * @param structObj The struct with account_address, module_name, and struct_name properties
+ * @returns The MoveStructId
+ */
+export const parseEncodedStruct = (structObj: {
+  account_address: string;
+  module_name: string;
+  struct_name: string;
+}): MoveStructId => {
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const { account_address, module_name, struct_name } = structObj;
+  const moduleName = hexToAscii(module_name);
+  const structName = hexToAscii(struct_name);
+  return `${account_address}::${moduleName}::${structName}`;
+};
+
+/**
+ * Determines whether the given object is an encoded struct type with the following properties:
+ * - account_address: string
+ * - module_name: string
+ * - struct_name: string
+ *
+ * @param structObj The object to check
+ * @returns Whether the object is an encoded struct type
+ */
+export const isEncodedStruct = (
+  structObj: any,
+): structObj is {
+  account_address: string;
+  module_name: string;
+  struct_name: string;
+} =>
+  typeof structObj === "object" &&
+  !Array.isArray(structObj) &&
+  structObj !== null &&
+  "account_address" in structObj &&
+  "module_name" in structObj &&
+  "struct_name" in structObj &&
+  typeof structObj.account_address === "string" &&
+  typeof structObj.module_name === "string" &&
+  typeof structObj.struct_name === "string";

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "1.27.1";
+export const VERSION = "1.28.0";

package/dist/common/chunk-CZKNJSPC.js

@@ -1,46 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-
-// src/utils/helpers.ts
-var _jsbase64 = require('js-base64');
-async function sleep(timeMs) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeMs);
-  });
-}
-var nowInSeconds = () => Math.floor(Date.now() / 1e3);
-function floorToWholeHour(timestampInSeconds) {
-  const date = new Date(timestampInSeconds * 1e3);
-  date.setMinutes(0);
-  date.setSeconds(0);
-  date.setMilliseconds(0);
-  return Math.floor(date.getTime() / 1e3);
-}
-function base64UrlDecode(base64Url) {
-  const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
-  const paddedBase64 = base64 + "==".substring(0, (3 - base64.length % 3) % 3);
-  const decodedString = _jsbase64.decode.call(void 0, paddedBase64);
-  return decodedString;
-}
-var convertAmountFromHumanReadableToOnChain = (value, decimal) => value * 10 ** decimal;
-var convertAmountFromOnChainToHumanReadable = (value, decimal) => value / 10 ** decimal;
-
-
-
-
-
-
-
-
-
-exports.__decorateClass = __decorateClass; exports.sleep = sleep; exports.nowInSeconds = nowInSeconds; exports.floorToWholeHour = floorToWholeHour; exports.base64UrlDecode = base64UrlDecode; exports.convertAmountFromHumanReadableToOnChain = convertAmountFromHumanReadableToOnChain; exports.convertAmountFromOnChainToHumanReadable = convertAmountFromOnChainToHumanReadable;
-//# sourceMappingURL=chunk-CZKNJSPC.js.map

package/dist/common/chunk-CZKNJSPC.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/helpers.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAGA,SAAS,cAAc;AAMvB,eAAsB,MAAM,QAA+B;AACzD,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,eAAW,SAAS,MAAM;AAAA,EAC5B,CAAC;AACH;AAEO,IAAM,eAAe,MAAM,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI;AAEvD,SAAS,iBAAiB,oBAAoC;AACnE,QAAM,OAAO,IAAI,KAAK,qBAAqB,GAAI;AAE/C,OAAK,WAAW,CAAC;AACjB,OAAK,WAAW,CAAC;AACjB,OAAK,gBAAgB,CAAC;AACtB,SAAO,KAAK,MAAM,KAAK,QAAQ,IAAI,GAAI;AACzC;AAEO,SAAS,gBAAgB,WAA2B;AAEzD,QAAM,SAAS,UAAU,QAAQ,MAAM,GAAG,EAAE,QAAQ,MAAM,GAAG;AAE7D,QAAM,eAAe,SAAS,KAAK,UAAU,IAAI,IAAK,OAAO,SAAS,KAAM,CAAC;AAC7E,QAAM,gBAAgB,OAAO,YAAY;AACzC,SAAO;AACT;AAaO,IAAM,0CAA0C,CAAC,OAAe,YAAoB,QAAQ,MAAM;AAalG,IAAM,0CAA0C,CAAC,OAAe,YAAoB,QAAQ,MAAM","sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { decode } from \"js-base64\";\n\n/**\n * Sleep the current thread for the given amount of time\n * @param timeMs time in milliseconds to sleep\n */\nexport async function sleep(timeMs: number): Promise<null> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeMs);\n  });\n}\n\nexport const nowInSeconds = () => Math.floor(Date.now() / 1000);\n\nexport function 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\nexport function base64UrlDecode(base64Url: string): string {\n  // Replace base64url-specific characters\n  const base64 = base64Url.replace(/-/g, \"+\").replace(/_/g, \"/\");\n  // Pad the string with '=' characters if needed\n  const paddedBase64 = base64 + \"==\".substring(0, (3 - (base64.length % 3)) % 3);\n  const decodedString = decode(paddedBase64);\n  return decodedString;\n}\n\n/**\n * Amount is represented in the smallest unit format on chain, this function converts\n * a human readable amount format to the smallest unit format\n * @example\n * human readable amount format: 500\n * on chain amount format when decimal is 8: 50000000000\n *\n * @param value The value in human readable format\n * @param decimal The token decimal\n * @returns The value is smallest units\n */\nexport const convertAmountFromHumanReadableToOnChain = (value: number, decimal: number) => value * 10 ** decimal;\n\n/**\n * Amount is represented in the smallest unit format on chain, this function converts\n * the smallest unit format to a human readable amount format\n * @example\n * human readable amount format: 500\n * on chain amount format when decimal is 8: 50000000000\n *\n * @param value The value in human readable format\n * @param decimal The token decimal\n * @returns The value is smallest units\n */\nexport const convertAmountFromOnChainToHumanReadable = (value: number, decimal: number) => value / 10 ** decimal;\n"]}

package/dist/esm/account/FederatedKeylessAccount.d.mts

@@ -1,177 +0,0 @@
-import { SigningScheme, HexInput } from '../types/index.mjs';
-import { AccountAddress, AccountAddressInput } from '../core/accountAddress.mjs';
-import { Deserializer } from '../bcs/deserializer.mjs';
-import { Serializable, Serializer } from '../bcs/serializer.mjs';
-import { ZeroKnowledgeSig, KeylessSignature } from '../core/crypto/keyless.mjs';
-import { A as Account } from '../Ed25519Account-B1VMJOY2.mjs';
-import { EphemeralKeyPair } from './EphemeralKeyPair.mjs';
-import { AccountAuthenticatorSingleKey } from '../transactions/authenticator/account.mjs';
-import { AnyRawTransaction } from '../transactions/types.mjs';
-import { FederatedKeylessPublicKey } from '../core/crypto/federatedKeyless.mjs';
-import { KeylessAccount, ProofFetchCallback } from './KeylessAccount.mjs';
-import '../utils/apiEndpoints.mjs';
-import '../types/indexer.mjs';
-import '../types/generated/operations.mjs';
-import '../types/generated/types.mjs';
-import '../core/common.mjs';
-import '../transactions/instances/transactionArgument.mjs';
-import '../core/hex.mjs';
-import '../publicKey-B3XRNhHO.mjs';
-import '../core/crypto/signature.mjs';
-import '../core/crypto/ephemeral.mjs';
-import '../core/crypto/proof.mjs';
-import '../types/keyless.mjs';
-import '../api/aptosConfig.mjs';
-import '../utils/const.mjs';
-import '../core/crypto/ed25519.mjs';
-import '../core/crypto/privateKey.mjs';
-import '../core/crypto/singleKey.mjs';
-import '../core/crypto/multiEd25519.mjs';
-import '../core/crypto/multiKey.mjs';
-import '../bcs/serializable/moveStructs.mjs';
-import '../bcs/serializable/movePrimitives.mjs';
-import '../bcs/serializable/fixedBytes.mjs';
-import '../transactions/instances/rawTransaction.mjs';
-import '../transactions/instances/chainId.mjs';
-import '../transactions/instances/transactionPayload.mjs';
-import '../transactions/instances/identifier.mjs';
-import '../transactions/instances/moduleId.mjs';
-import '../transactions/typeTag/index.mjs';
-import '../transactions/instances/simpleTransaction.mjs';
-import '../transactions/instances/multiAgentTransaction.mjs';
-
-/**
- * Account implementation for the Keyless authentication scheme.
- *
- * Used to represent a Keyless based account and sign transactions with it.
- *
- * Use KeylessAccount.fromJWTAndProof to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.
- *
- * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,
- * EphemeralKeyPair, and corresponding proof.
- */
-declare class FederatedKeylessAccount extends Serializable implements Account {
-    static readonly PEPPER_LENGTH: number;
-    /**
-     * The KeylessPublicKey associated with the account
-     */
-    readonly publicKey: FederatedKeylessPublicKey;
-    /**
-     * The EphemeralKeyPair used to generate sign.
-     */
-    readonly ephemeralKeyPair: EphemeralKeyPair;
-    /**
-     * The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
-     */
-    readonly uidKey: string;
-    /**
-     * The value of the uidKey claim on the JWT.  This intended to be a stable user identifier.
-     */
-    readonly uidVal: string;
-    /**
-     * The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
-     * OIDC registration with the identity provider.
-     */
-    readonly aud: string;
-    /**
-     * A value contains 31 bytes of entropy that preserves privacy of the account. Typically fetched from a pepper provider.
-     */
-    readonly pepper: Uint8Array;
-    /**
-     * Account address associated with the account
-     */
-    readonly accountAddress: AccountAddress;
-    /**
-     * The zero knowledge signature (if ready) which contains the proof used to validate the EphemeralKeyPair.
-     */
-    proof: ZeroKnowledgeSig | undefined;
-    /**
-     * The proof of the EphemeralKeyPair or a promise that provides the proof.  This is used to allow for awaiting on
-     * fetching the proof.
-     */
-    readonly proofOrPromise: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
-    /**
-     * Signing scheme used to sign transactions
-     */
-    readonly signingScheme: SigningScheme;
-    /**
-     * The JWT token used to derive the account
-     */
-    readonly jwt: string;
-    /**
-     * An event emitter used to assist in handling asycronous proof fetching.
-     */
-    private readonly emitter;
-    private constructor();
-    /**
-     * This initializes the asyncronous proof fetch
-     * @return
-     */
-    init(promise: Promise<ZeroKnowledgeSig>): Promise<void>;
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): FederatedKeylessAccount;
-    /**
-     * Checks if the proof is expired.  If so the account must be rederived with a new EphemeralKeyPair
-     * and JWT token.
-     * @return boolean
-     */
-    isExpired(): boolean;
-    /**
-     * Sign a message using Keyless.
-     * @param message the message to sign, as binary input
-     * @return the AccountAuthenticator containing the signature, together with the account's public key
-     */
-    signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey;
-    /**
-     * Sign a transaction using Keyless.
-     * @param transaction the raw transaction
-     * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
-     */
-    signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey;
-    /**
-     * Waits for asyncronous proof fetching to finish.
-     * @return
-     */
-    waitForProofFetch(): Promise<void>;
-    /**
-     * Sign the given message using Keyless.
-     * @param message in HexInput format
-     * @returns Signature
-     */
-    sign(data: HexInput): KeylessSignature;
-    /**
-     * Sign the given transaction with Keyless.
-     * Signs the transaction and proof to guard against proof malleability.
-     * @param transaction the transaction to be signed
-     * @returns KeylessSignature
-     */
-    signTransaction(transaction: AnyRawTransaction): KeylessSignature;
-    /**
-     * Note - This function is currently incomplete and should only be used to verify ownership of the KeylessAccount
-     *
-     * Verifies a signature given the message.
-     *
-     * TODO: Groth16 proof verification
-     *
-     * @param args.message the message that was signed.
-     * @param args.signature the KeylessSignature to verify
-     * @returns boolean
-     */
-    verifySignature(args: {
-        message: HexInput;
-        signature: KeylessSignature;
-    }): boolean;
-    static fromBytes(bytes: Uint8Array): KeylessAccount;
-    static create(args: {
-        address?: AccountAddress;
-        proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
-        jwt: string;
-        ephemeralKeyPair: EphemeralKeyPair;
-        pepper: HexInput;
-        jwkAddress: AccountAddressInput;
-        uidKey?: string;
-        proofFetchCallback?: ProofFetchCallback;
-    }): FederatedKeylessAccount;
-}
-
-export { FederatedKeylessAccount };

package/dist/esm/account/FederatedKeylessAccount.mjs

@@ -1,71 +0,0 @@
-import {
-  FederatedKeylessAccount
-} from "../chunk-6SEUVXPK.mjs";
-import "../chunk-LD2CRNA2.mjs";
-import "../chunk-LMUNGBGS.mjs";
-import "../chunk-4NMDYPUD.mjs";
-import "../chunk-64OZO6BS.mjs";
-import "../chunk-PNGNBHMD.mjs";
-import "../chunk-LMUCX6RP.mjs";
-import "../chunk-WVT25KQR.mjs";
-import "../chunk-NGUFBDTH.mjs";
-import "../chunk-UYVPNUH3.mjs";
-import "../chunk-XUNU6GVQ.mjs";
-import "../chunk-P3RTJ6VC.mjs";
-import "../chunk-I2ZYQVA3.mjs";
-import "../chunk-MQALTYRJ.mjs";
-import "../chunk-26HCJOBL.mjs";
-import "../chunk-YJJTCGDT.mjs";
-import "../chunk-YQPKNTIN.mjs";
-import "../chunk-E7FWVXGX.mjs";
-import "../chunk-NECL5FCQ.mjs";
-import "../chunk-4QMXOWHP.mjs";
-import "../chunk-V2LEZDNS.mjs";
-import "../chunk-3V5WGOZH.mjs";
-import "../chunk-AQ4I7VVB.mjs";
-import "../chunk-XBY4UM6M.mjs";
-import "../chunk-KUX6GQ2E.mjs";
-import "../chunk-NYELBSVO.mjs";
-import "../chunk-SRKSXJ5U.mjs";
-import "../chunk-BBCNBKEC.mjs";
-import "../chunk-BMXV6WQK.mjs";
-import "../chunk-JWEFNE2S.mjs";
-import "../chunk-IX2XMCWZ.mjs";
-import "../chunk-NUA7L6XF.mjs";
-import "../chunk-GKF3HFY2.mjs";
-import "../chunk-B673XLJY.mjs";
-import "../chunk-NMKCJNQM.mjs";
-import "../chunk-L3E7YJBM.mjs";
-import "../chunk-6BI4XTJN.mjs";
-import "../chunk-PU5AFUX3.mjs";
-import "../chunk-ANOJYMO2.mjs";
-import "../chunk-IUC6XUYA.mjs";
-import "../chunk-EYHRMZPO.mjs";
-import "../chunk-N2FKVZ4D.mjs";
-import "../chunk-HCIGCJ62.mjs";
-import "../chunk-2UN35LUX.mjs";
-import "../chunk-EPUYKFAT.mjs";
-import "../chunk-HGLO5LDS.mjs";
-import "../chunk-G2VEDGO7.mjs";
-import "../chunk-LITCPMVC.mjs";
-import "../chunk-YPHGPN2P.mjs";
-import "../chunk-3NHOLSZE.mjs";
-import "../chunk-4K4TZF3H.mjs";
-import "../chunk-FZY4PMEE.mjs";
-import "../chunk-PSW5OBY2.mjs";
-import "../chunk-GWS7OLIU.mjs";
-import "../chunk-6AO2MJMN.mjs";
-import "../chunk-ACAXM6CI.mjs";
-import "../chunk-4FVXWQGX.mjs";
-import "../chunk-4WPQQPUF.mjs";
-import "../chunk-6J7C4S3H.mjs";
-import "../chunk-UZXDD3QH.mjs";
-import "../chunk-YV7M4CFP.mjs";
-import "../chunk-QMM2KL6C.mjs";
-import "../chunk-SBB4YEPT.mjs";
-import "../chunk-N6K44CGJ.mjs";
-import "../chunk-OR7TEZ25.mjs";
-export {
-  FederatedKeylessAccount
-};
-//# sourceMappingURL=FederatedKeylessAccount.mjs.map

package/dist/esm/chunk-26HCJOBL.mjs

@@ -1,23 +0,0 @@
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.mjs";
-
-// src/transactions/instances/chainId.ts
-var ChainId = class _ChainId extends Serializable {
-  constructor(chainId) {
-    super();
-    this.chainId = chainId;
-  }
-  serialize(serializer) {
-    serializer.serializeU8(this.chainId);
-  }
-  static deserialize(deserializer) {
-    const chainId = deserializer.deserializeU8();
-    return new _ChainId(chainId);
-  }
-};
-
-export {
-  ChainId
-};
-//# sourceMappingURL=chunk-26HCJOBL.mjs.map