@aptos-labs/ts-sdk 1.27.1 → 1.28.0

package/dist/esm/utils/helpers.d.mts

@@ -1,3 +1,9 @@
+import { MoveStructId } from '../types/index.mjs';
+import './apiEndpoints.mjs';
+import '../types/indexer.mjs';
+import '../types/generated/operations.mjs';
+import '../types/generated/types.mjs';
+
 /**
  * Sleep the current thread for the given amount of time
  * @param timeMs time in milliseconds to sleep
@@ -30,5 +36,39 @@ declare const convertAmountFromHumanReadableToOnChain: (value: number, decimal:
  * @returns The value is smallest units
  */
 declare const convertAmountFromOnChainToHumanReadable: (value: number, decimal: number) => number;
+/**
+ * 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
+ */
+declare const parseEncodedStruct: (structObj: {
+    account_address: string;
+    module_name: string;
+    struct_name: string;
+}) => MoveStructId;
+/**
+ * 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
+ */
+declare const isEncodedStruct: (structObj: any) => structObj is {
+    account_address: string;
+    module_name: string;
+    struct_name: string;
+};
 
-export { base64UrlDecode, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, floorToWholeHour, nowInSeconds, sleep };
+export { base64UrlDecode, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, floorToWholeHour, isEncodedStruct, nowInSeconds, parseEncodedStruct, sleep };

package/dist/esm/utils/helpers.mjs

@@ -1,2 +1,2 @@
-import{a,b,c,d,e,f}from"../chunk-ZOMXBB6Z.mjs";import"../chunk-FVA2OPG4.mjs";export{d as base64UrlDecode,e as convertAmountFromHumanReadableToOnChain,f as convertAmountFromOnChainToHumanReadable,c as floorToWholeHour,b as nowInSeconds,a as sleep};
+import{a,b,c,d,e,f,g,h}from"../chunk-UAL27G6B.mjs";import"../chunk-FVA2OPG4.mjs";export{d as base64UrlDecode,e as convertAmountFromHumanReadableToOnChain,f as convertAmountFromOnChainToHumanReadable,c as floorToWholeHour,h as isEncodedStruct,b as nowInSeconds,g as parseEncodedStruct,a as sleep};
 //# sourceMappingURL=helpers.mjs.map

package/dist/esm/utils/index.d.mts

@@ -1,7 +1,7 @@
 export { Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, NetworkToPepperAPI, NetworkToProverAPI } from './apiEndpoints.mjs';
-export { APTOS_COIN, AptosApiType, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, ProcessorType, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT } from './const.mjs';
+export { APTOS_COIN, APTOS_FA, AptosApiType, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, ProcessorType, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT } from './const.mjs';
 export { DeserializableClass, normalizeBundle } from './normalizeBundle.mjs';
-export { base64UrlDecode, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, floorToWholeHour, nowInSeconds, sleep } from './helpers.mjs';
+export { base64UrlDecode, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, floorToWholeHour, isEncodedStruct, nowInSeconds, parseEncodedStruct, sleep } from './helpers.mjs';
 import '../bcs/deserializer.mjs';
 import '../types/index.mjs';
 import '../types/indexer.mjs';

package/dist/esm/utils/index.mjs

@@ -1,2 +1,2 @@
-import"../chunk-HGLO5LDS.mjs";import{a as q}from"../chunk-BSUYPXRD.mjs";import{a as r,b as s,c as t,d as u,e as v,f as w}from"../chunk-ZOMXBB6Z.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-KMJ6TF6Y.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-THRXIXIO.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-KEYAPEAX.mjs";import"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import{a as i,b as j,c as k,d as l,e as m,f as n,g as o,h as p}from"../chunk-SCHZ67F3.mjs";import{a,b,c,d,e,f,g,h}from"../chunk-L36ZHC7J.mjs";import"../chunk-FVA2OPG4.mjs";export{e as APTOS_COIN,a as AptosApiType,b as DEFAULT_MAX_GAS_AMOUNT,c as DEFAULT_TXN_EXP_SEC_FROM_NOW,d as DEFAULT_TXN_TIMEOUT_SEC,n as Network,o as NetworkToChainId,k as NetworkToFaucetAPI,i as NetworkToIndexerAPI,p as NetworkToNetworkName,j as NetworkToNodeAPI,l as NetworkToPepperAPI,m as NetworkToProverAPI,h as ProcessorType,f as RAW_TRANSACTION_SALT,g as RAW_TRANSACTION_WITH_DATA_SALT,u as base64UrlDecode,v as convertAmountFromHumanReadableToOnChain,w as convertAmountFromOnChainToHumanReadable,t as floorToWholeHour,q as normalizeBundle,s as nowInSeconds,r as sleep};
+import"../chunk-HGLO5LDS.mjs";import{a as r}from"../chunk-BSUYPXRD.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-QQU4IQ27.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-G773HST5.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-KEYAPEAX.mjs";import"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import{a as s,b as t,c as u,d as v,e as w,f as x,g as y,h as z}from"../chunk-UAL27G6B.mjs";import{a as j,b as k,c as l,d as m,e as n,f as o,g as p,h as q}from"../chunk-SCHZ67F3.mjs";import{a,b,c,d,e,f,g,h,i}from"../chunk-EXP5STXZ.mjs";import"../chunk-FVA2OPG4.mjs";export{e as APTOS_COIN,f as APTOS_FA,a as AptosApiType,b as DEFAULT_MAX_GAS_AMOUNT,c as DEFAULT_TXN_EXP_SEC_FROM_NOW,d as DEFAULT_TXN_TIMEOUT_SEC,o as Network,p as NetworkToChainId,l as NetworkToFaucetAPI,j as NetworkToIndexerAPI,q as NetworkToNetworkName,k as NetworkToNodeAPI,m as NetworkToPepperAPI,n as NetworkToProverAPI,i as ProcessorType,g as RAW_TRANSACTION_SALT,h as RAW_TRANSACTION_WITH_DATA_SALT,v as base64UrlDecode,w as convertAmountFromHumanReadableToOnChain,x as convertAmountFromOnChainToHumanReadable,u as floorToWholeHour,z as isEncodedStruct,r as normalizeBundle,t as nowInSeconds,y as parseEncodedStruct,s as sleep};
 //# sourceMappingURL=index.mjs.map

package/dist/esm/utils/normalizeBundle.mjs

@@ -1,2 +1,2 @@
-import{a}from"../chunk-BSUYPXRD.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-KMJ6TF6Y.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-THRXIXIO.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-KEYAPEAX.mjs";import"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-FVA2OPG4.mjs";export{a as normalizeBundle};
+import{a}from"../chunk-BSUYPXRD.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-QQU4IQ27.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-G773HST5.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-KEYAPEAX.mjs";import"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-FVA2OPG4.mjs";export{a as normalizeBundle};
 //# sourceMappingURL=normalizeBundle.mjs.map

package/dist/esm/version.d.mts

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

package/dist/esm/version.mjs

@@ -1,2 +1,2 @@
-import{a}from"./chunk-ZEYOFDIO.mjs";import"./chunk-FVA2OPG4.mjs";export{a as VERSION};
+import{a}from"./chunk-ZXVQ2OBJ.mjs";import"./chunk-FVA2OPG4.mjs";export{a as VERSION};
 //# sourceMappingURL=version.mjs.map

package/package.json

@@ -95,5 +95,5 @@
     "typedoc": "^0.25.4",
     "typescript": "^5.3.3"
   },
-  "version": "1.27.1"
+  "version": "1.28.0"
 }

package/src/account/MultiKeyAccount.ts

@@ -3,7 +3,7 @@
 
 import { Account } from "./Account";
 import { MultiKey, MultiKeySignature, PublicKey } from "../core/crypto";
-import { AccountAddress } from "../core/accountAddress";
+import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { HexInput, SigningScheme } from "../types";
 import { AccountAuthenticatorMultiKey } from "../transactions/authenticator/account";
 import { AnyRawTransaction } from "../transactions/types";
@@ -61,13 +61,13 @@ export class MultiKeyAccount implements Account {
    * @param args.signers an array of M signers that will be used to sign the transaction
    * @returns MultiKeyAccount
    */
-  constructor(args: { multiKey: MultiKey; signers: Account[] }) {
-    const { multiKey, signers } = args;
+  constructor(args: { multiKey: MultiKey; signers: Account[]; address?: AccountAddressInput }) {
+    const { multiKey, signers, address } = args;
 
     this.publicKey = multiKey;
     this.signingScheme = SigningScheme.MultiKey;
 
-    this.accountAddress = this.publicKey.authKey().derivedAddress();
+    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
 
     // Get the index of each respective signer in the bitmap
     const bitPositions: number[] = [];

package/src/api/account.ts

@@ -15,6 +15,7 @@ import {
   MoveModuleBytecode,
   MoveResource,
   MoveStructId,
+  MoveValue,
   OrderByArg,
   PaginationArgs,
   TokenStandardArg,
@@ -40,10 +41,12 @@ import {
   getTransactions,
   lookupOriginalAccountAddress,
 } from "../internal/account";
-import { APTOS_COIN, ProcessorType } from "../utils/const";
+import { APTOS_COIN, APTOS_FA, ProcessorType } from "../utils/const";
 import { AptosConfig } from "./aptosConfig";
 import { waitForIndexerOnVersion } from "./utils";
 import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
+import { view } from "../internal/view";
+import { isEncodedStruct, parseEncodedStruct } from "../utils";
 
 /**
  * A class to query all `Account` related queries on Aptos.
@@ -428,7 +431,7 @@ export class Account {
     accountAddress: AccountAddressInput;
     minimumLedgerVersion?: AnyNumber;
   }): Promise<number> {
-    return this.getAccountCoinAmount({ coinType: APTOS_COIN, ...args });
+    return this.getAccountCoinAmount({ coinType: APTOS_COIN, faMetadataAddress: APTOS_FA, ...args });
   }
 
   /**
@@ -438,7 +441,8 @@ export class Account {
    * const accountCoinAmount = await aptos.getAccountCoinAmount({accountAddress:"0x123", coinType:"0x1::aptos_coin::AptosCoin"})
    *
    * @param args.accountAddress The account address we want to get the total count for
-   * @param args.coinType The coin type to query
+   * @param args.coinType The coin type to query.
+   *        Note: faMetadataAddress will automatically fill this in if not provided when migrated to fungible assets
    * @param args.faMetadataAddress The fungible asset metadata address to query.
    *        Note: coinType will automatically fill this in if not provided when migrated to fungible assets
    * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
@@ -450,12 +454,35 @@ export class Account {
     faMetadataAddress?: AccountAddressInput;
     minimumLedgerVersion?: AnyNumber;
   }): Promise<number> {
+    const { coinType, faMetadataAddress } = args;
     await waitForIndexerOnVersion({
       config: this.config,
       minimumLedgerVersion: args.minimumLedgerVersion,
       processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,
     });
-    return getAccountCoinAmount({ aptosConfig: this.config, ...args });
+
+    // Attempt to populate the CoinType field if the FA address is provided.
+    // We cannot do this internally due to dependency cycles issue.
+    let coinAssetType: MoveStructId | undefined = coinType;
+    if (coinType === undefined && faMetadataAddress !== undefined) {
+      try {
+        const pairedCoinTypeStruct = (
+          await view({
+            aptosConfig: this.config,
+            payload: { function: "0x1::coin::paired_coin", functionArguments: [faMetadataAddress] },
+          })
+        ).at(0) as { vec: MoveValue[] };
+
+        // Check if the Option has a value, and if so, parse the struct
+        if (pairedCoinTypeStruct.vec.length > 0 && isEncodedStruct(pairedCoinTypeStruct.vec[0])) {
+          coinAssetType = parseEncodedStruct(pairedCoinTypeStruct.vec[0]);
+        }
+      } catch (error) {
+        /* No paired coin type found */
+      }
+    }
+
+    return getAccountCoinAmount({ aptosConfig: this.config, ...args, coinType: coinAssetType });
   }
 
   /**

package/src/bcs/serializable/moveStructs.ts

@@ -67,13 +67,12 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * @param serializer
    */
   serializeForScriptFunction(serializer: Serializer): void {
-    // runtime check to ensure that you can't serialize anything other than vector<u8>
-    const isU8 = this.values[0] instanceof U8;
-    // if the inner array is length 0, we can't check the type because it has no instance, so we assume it's a u8
-    // it may not be, but we don't care because regardless of a vector's type,
-    // a zero-length vector is serialized to a single byte value: 0
-    if (!isU8 && this.values[0] !== undefined) {
-      throw new Error("Script function arguments only accept u8 vectors");
+    // This checks if the type of a non-empty vector is of type other than U8.  If so, we use the Serialized
+    // transaction argument type to serialize the argument.
+    if (this.values[0] !== undefined && !(this.values[0] instanceof U8)) {
+      const serialized = new Serialized(this.bcsToBytes());
+      serialized.serializeForScriptFunction(serializer);
+      return;
     }
     serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U8Vector);
     serializer.serialize(this);
@@ -225,6 +224,39 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
   }
 }
 
+export class Serialized extends Serializable implements TransactionArgument {
+  public readonly value: Uint8Array;
+
+  constructor(value: HexInput) {
+    super();
+    this.value = Hex.fromHexInput(value).toUint8Array();
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.value);
+  }
+
+  serializeForEntryFunction(serializer: Serializer): void {
+    this.serialize(serializer);
+  }
+
+  serializeForScriptFunction(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.Serialized);
+    this.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): Serialized {
+    return new Serialized(deserializer.deserializeBytes());
+  }
+
+  toMoveVector<T extends Serializable & EntryFunctionArgument>(cls: Deserializable<T>): MoveVector<T> {
+    const deserializer = new Deserializer(this.bcsToBytes());
+    deserializer.deserializeUleb128AsU32();
+    const vec = deserializer.deserializeVector(cls);
+    return new MoveVector(vec);
+  }
+}
+
 export class MoveString extends Serializable implements TransactionArgument {
   public value: string;
 
@@ -244,7 +276,8 @@ export class MoveString extends Serializable implements TransactionArgument {
 
   serializeForScriptFunction(serializer: Serializer): void {
     // Serialize the string as a fixed byte string, i.e., without the length prefix
-    const fixedStringBytes = this.bcsToBytes().slice(1);
+    const textEncoder = new TextEncoder();
+    const fixedStringBytes = textEncoder.encode(this.value);
     // Put those bytes into a vector<u8> and serialize it as a script function argument
     const vectorU8 = MoveVector.U8(fixedStringBytes);
     vectorU8.serializeForScriptFunction(serializer);

package/src/cli/move.ts

@@ -425,7 +425,7 @@ export class Move {
    */
   // eslint-disable-next-line class-methods-use-this
   private extractAddressFromOutput(output: string): string {
-    const match = output.match("Code was successfully deployed to object address (0x[0-9a-fA-F]+)\\.");
+    const match = output.match("Code was successfully deployed to object address (0x[0-9a-fA-F]+)");
     if (match) {
       return match[1];
     }

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/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,
 }
 
 /**

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-J4IUXT5W.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var u=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var d=(n,e,t,r)=>{for(var o=r>1?void 0:r?a(e,t):e,s=n.length-1,c;s>=0;s--)(c=n[s])&&(o=(r?c(e,t,o):c(o))||o);return r&&o&&u(e,t,o),o};var _jsbase64 = require('js-base64');async function b(n){return new Promise(e=>{setTimeout(e,n)})}var p=()=>Math.floor(Date.now()/1e3);function g(n){let e=new Date(n*1e3);return e.setMinutes(0),e.setSeconds(0),e.setMilliseconds(0),Math.floor(e.getTime()/1e3)}function f(n){let e=n.replace(/-/g,"+").replace(/_/g,"/"),t=e+"==".substring(0,(3-e.length%3)%3);return _jsbase64.decode.call(void 0, t)}var h=(n,e)=>n*10**e,x= exports.g =(n,e)=>n/10**e;exports.a = d; exports.b = b; exports.c = p; exports.d = g; exports.e = f; exports.f = h; exports.g = x;
-//# sourceMappingURL=chunk-J4IUXT5W.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/helpers.ts"],"names":["decode","sleep","timeMs","resolve","nowInSeconds","floorToWholeHour","timestampInSeconds","date","base64UrlDecode","base64Url","base64","paddedBase64","convertAmountFromHumanReadableToOnChain","value","decimal","convertAmountFromOnChainToHumanReadable"],"mappings":"wMAGA,OAAS,UAAAA,MAAc,YAMvB,eAAsBC,EAAMC,EAA+B,CACzD,OAAO,IAAI,QAASC,GAAY,CAC9B,WAAWA,EAASD,CAAM,CAC5B,CAAC,CACH,CAEO,IAAME,EAAe,IAAM,KAAK,MAAM,KAAK,IAAI,EAAI,GAAI,EAEvD,SAASC,EAAiBC,EAAoC,CACnE,IAAMC,EAAO,IAAI,KAAKD,EAAqB,GAAI,EAE/C,OAAAC,EAAK,WAAW,CAAC,EACjBA,EAAK,WAAW,CAAC,EACjBA,EAAK,gBAAgB,CAAC,EACf,KAAK,MAAMA,EAAK,QAAQ,EAAI,GAAI,CACzC,CAEO,SAASC,EAAgBC,EAA2B,CAEzD,IAAMC,EAASD,EAAU,QAAQ,KAAM,GAAG,EAAE,QAAQ,KAAM,GAAG,EAEvDE,EAAeD,EAAS,KAAK,UAAU,GAAI,EAAKA,EAAO,OAAS,GAAM,CAAC,EAE7E,OADsBV,EAAOW,CAAY,CAE3C,CAaO,IAAMC,EAA0C,CAACC,EAAeC,IAAoBD,EAAQ,IAAMC,EAa5FC,EAA0C,CAACF,EAAeC,IAAoBD,EAAQ,IAAMC","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/chunk-4SDUQ7AS.mjs

@@ -1,2 +0,0 @@
-import{a as n}from"./chunk-PY4TS34X.mjs";import{a as s,b as t,c as r,d as i,e as c,f as u,g as d,h as A,i as g,j as m,k as a,l as p,m as f,n as y,o as C,p as T,q as O}from"./chunk-HHU7UCFI.mjs";import{e as o}from"./chunk-L36ZHC7J.mjs";var l=class{constructor(e){this.config=e}async getAccountInfo(e){return s({aptosConfig:this.config,...e})}async getAccountModules(e){return t({aptosConfig:this.config,...e})}async getAccountModule(e){return r({aptosConfig:this.config,...e})}async getAccountTransactions(e){return i({aptosConfig:this.config,...e})}async getAccountResources(e){return c({aptosConfig:this.config,...e})}async getAccountResource(e){return u({aptosConfig:this.config,...e})}async lookupOriginalAccountAddress(e){return d({aptosConfig:this.config,...e})}async getAccountTokensCount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"account_transactions_processor"}),A({aptosConfig:this.config,...e})}async getAccountOwnedTokens(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"token_v2_processor"}),g({aptosConfig:this.config,...e})}async getAccountOwnedTokensFromCollectionAddress(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"token_v2_processor"}),m({aptosConfig:this.config,...e})}async getAccountCollectionsWithOwnedTokens(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"token_v2_processor"}),a({aptosConfig:this.config,...e})}async getAccountTransactionsCount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"account_transactions_processor"}),p({aptosConfig:this.config,...e})}async getAccountCoinsData(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"fungible_asset_processor"}),y({aptosConfig:this.config,...e})}async getAccountCoinsCount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"fungible_asset_processor"}),C({aptosConfig:this.config,...e})}async getAccountAPTAmount(e){return this.getAccountCoinAmount({coinType:o,...e})}async getAccountCoinAmount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"fungible_asset_processor"}),f({aptosConfig:this.config,...e})}async getAccountOwnedObjects(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorType:"default_processor"}),T({aptosConfig:this.config,...e})}async deriveAccountFromPrivateKey(e){return O({aptosConfig:this.config,...e})}};export{l as a};
-//# sourceMappingURL=chunk-4SDUQ7AS.mjs.map

package/dist/esm/chunk-4SDUQ7AS.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/account.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Account as AccountModule } from \"../account\";\nimport { AccountAddress, PrivateKey, AccountAddressInput } from \"../core\";\nimport {\n  AccountData,\n  AnyNumber,\n  GetAccountCoinsDataResponse,\n  GetAccountCollectionsWithOwnedTokenResponse,\n  GetAccountOwnedTokensFromCollectionResponse,\n  GetAccountOwnedTokensQueryResponse,\n  GetObjectDataQueryResponse,\n  LedgerVersionArg,\n  MoveModuleBytecode,\n  MoveResource,\n  MoveStructId,\n  OrderByArg,\n  PaginationArgs,\n  TokenStandardArg,\n  TransactionResponse,\n  WhereArg,\n} from \"../types\";\nimport {\n  deriveAccountFromPrivateKey,\n  getAccountCoinAmount,\n  getAccountCoinsCount,\n  getAccountCoinsData,\n  getAccountCollectionsWithOwnedTokens,\n  getAccountOwnedObjects,\n  getAccountOwnedTokens,\n  getAccountOwnedTokensFromCollectionAddress,\n  getAccountTokensCount,\n  getAccountTransactionsCount,\n  getInfo,\n  getModule,\n  getModules,\n  getResource,\n  getResources,\n  getTransactions,\n  lookupOriginalAccountAddress,\n} from \"../internal/account\";\nimport { APTOS_COIN, ProcessorType } from \"../utils/const\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { waitForIndexerOnVersion } from \"./utils\";\nimport { CurrentFungibleAssetBalancesBoolExp } from \"../types/generated/types\";\n\n/**\n * A class to query all `Account` related queries on Aptos.\n */\nexport class Account {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Queries the current state for an Aptos account given its account address\n   *\n   * @param args.accountAddress Aptos account address\n   *\n   * @returns The account data\n   *\n   * @example An example of the returned account\n   * ```\n   * {\n   *    sequence_number: \"1\",\n   *    authentication_key: \"0x5307b5f4bc67829097a8ba9b43dba3b88261eeccd1f709d9bde240fc100fbb69\"\n   * }\n   * ```\n   */\n  async getAccountInfo(args: { accountAddress: AccountAddressInput }): Promise<AccountData> {\n    return getInfo({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for all modules in an account given an account address\n   *\n   * Note: In order to get all account modules, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number module to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account modules\n   */\n\n  async getAccountModules(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs & LedgerVersionArg;\n  }): Promise<MoveModuleBytecode[]> {\n    return getModules({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for a specific account module given account address and module name\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.moduleName The name of the module\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account module\n   *\n   * @example\n   * const module = await aptos.getAccountModule({accountAddress:\"0x456\"})\n   * // An example of an account module response\n   * ```\n   * {\n   *    bytecode: \"0xa11ceb0b0600000006010002030206050807070f0d081c200\",\n   *    abi: { address: \"0x1\" }\n   * }\n   * ```\n   */\n  async getAccountModule(args: {\n    accountAddress: AccountAddressInput;\n    moduleName: string;\n    options?: LedgerVersionArg;\n  }): Promise<MoveModuleBytecode> {\n    return getModule({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries account transactions given an account address\n   *\n   * Note: In order to get all account transactions, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @example\n   * const transactions = await aptos.getAccountTransactions({accountAddress:\"0x456\"})\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number transaction to start returning results from\n   * @param args.options.limit The number of results to return\n   *\n   * @returns The account transactions\n   */\n  async getAccountTransactions(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs;\n  }): Promise<TransactionResponse[]> {\n    return getTransactions({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries all account resources given an account address\n   *\n   * Note: In order to get all account resources, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @example\n   * const resources = await aptos.getAccountResources({accountAddress:\"0x456\"})\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number resource to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   * @returns Account resources\n   */\n  async getAccountResources(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs & LedgerVersionArg;\n  }): Promise<MoveResource[]> {\n    return getResources({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries a specific account resource given account address and resource type. Note that the default is `any` in order\n   * to allow for ease of accessing properties of the object.\n   *\n   * @type The typed output of the resource\n   * @param args.accountAddress Aptos account address\n   * @param args.resourceType String representation of an on-chain Move struct type, i.e \"0x1::aptos_coin::AptosCoin\"\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account resource\n   *\n   * @example\n   * const resource = await aptos.getAccountResource({accountAddress:\"0x456\"})\n   *\n   */\n  async getAccountResource<T extends {} = any>(args: {\n    accountAddress: AccountAddressInput;\n    resourceType: MoveStructId;\n    options?: LedgerVersionArg;\n  }): Promise<T> {\n    return getResource<T>({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Looks up the account address for a given authentication key\n   *\n   * This handles both if the account's authentication key has been rotated or not.\n   *\n   * @example\n   * const accountAddress = await aptos.lookupOriginalAccountAddress({authenticationKey:account.accountAddress})\n   *\n   * @param args.authenticationKey The authentication key\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   * @returns Promise<AccountAddress> The accountAddress associated with the authentication key\n   */\n  async lookupOriginalAccountAddress(args: {\n    authenticationKey: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: LedgerVersionArg;\n  }): Promise<AccountAddress> {\n    return lookupOriginalAccountAddress({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries the current count of tokens owned by an account\n   *\n   * @example\n   * const tokensCount = await aptos.getAccountTokensCount({accountAddress:\"0x456\"})\n   *\n   * @param args.accountAddress The account address\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of tokens owned by the account\n   */\n  async getAccountTokensCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR,\n    });\n    return getAccountTokensCount({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the account's current owned tokens.\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @example\n   * const accountOwnedTokens = await aptos.getAccountOwnedTokens({accountAddress:\"0x456\"})\n   *\n   * @param args.accountAddress The account address we want to get the tokens for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number token to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Tokens array with the token data\n   */\n  async getAccountOwnedTokens(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;\n  }): Promise<GetAccountOwnedTokensQueryResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.TOKEN_V2_PROCESSOR,\n    });\n    return getAccountOwnedTokens({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries all current tokens of a specific collection that an account owns by the collection address\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @example\n   * const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({accountAddress:\"0x123\", collectionAddress:\"0x456\"})\n   *\n   * @param args.accountAddress The account address we want to get the tokens for\n   * @param args.collectionAddress The address of the collection being queried\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number token to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Tokens array with the token data\n   */\n  async getAccountOwnedTokensFromCollectionAddress(args: {\n    accountAddress: AccountAddressInput;\n    collectionAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;\n  }): Promise<GetAccountOwnedTokensFromCollectionResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.TOKEN_V2_PROCESSOR,\n    });\n    return getAccountOwnedTokensFromCollectionAddress({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries for all collections that an account currently has tokens for.\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @example\n   * const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the collections for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number collection to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Collections array with the collections data\n   */\n  async getAccountCollectionsWithOwnedTokens(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;\n  }): Promise<GetAccountCollectionsWithOwnedTokenResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.TOKEN_V2_PROCESSOR,\n    });\n    return getAccountCollectionsWithOwnedTokens({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the current count of transactions submitted by an account\n   *\n   * @example\n   * const accountTransactionsCount = await aptos.getAccountTransactionsCount({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of transactions made by an account\n   */\n  async getAccountTransactionsCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR,\n    });\n    return getAccountTransactionsCount({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries an account's coins data\n   *\n   * @example\n   * const accountCoinsData = await aptos.getAccountCoinsData({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the coins data for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.offset optional. The number coin to start returning results from\n   * @param args.options.limit optional. The number of results to return\n   * @param args.options.orderBy optional. The order to sort the coins by\n   * @param args.options.where optional. Filter the results by\n   * @returns Array with the coins data\n   */\n  async getAccountCoinsData(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs &\n      OrderByArg<GetAccountCoinsDataResponse[0]> &\n      WhereArg<CurrentFungibleAssetBalancesBoolExp>;\n  }): Promise<GetAccountCoinsDataResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getAccountCoinsData({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the current count of an account's coins aggregated\n   *\n   * @example\n   * const accountCoinsCount = await aptos.getAccountCoinsCount({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of the aggregated count of all account's coins\n   */\n  async getAccountCoinsCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getAccountCoinsCount({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries the account's APT amount\n   *\n   * @example\n   * const accountAPTAmount = await aptos.getAccountAPTAmount({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current amount of account's APT\n   */\n  async getAccountAPTAmount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    return this.getAccountCoinAmount({ coinType: APTOS_COIN, ...args });\n  }\n\n  /**\n   * Queries the account's coin amount by the coin type\n   *\n   * @example\n   * const accountCoinAmount = await aptos.getAccountCoinAmount({accountAddress:\"0x123\", coinType:\"0x1::aptos_coin::AptosCoin\"})\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.coinType The coin type to query\n   * @param args.faMetadataAddress The fungible asset metadata address to query.\n   *        Note: coinType will automatically fill this in if not provided when migrated to fungible assets\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current amount of account's coin\n   */\n  async getAccountCoinAmount(args: {\n    accountAddress: AccountAddressInput;\n    coinType?: MoveStructId;\n    faMetadataAddress?: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getAccountCoinAmount({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries an account's owned objects\n   *\n   * @example\n   * const accountOwnedObjects = await aptos.getAccountOwnedObjects({accountAddress:\"0x123\"})\n   *\n   * @param args.accountAddress The account address we want to get the objects for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.offset The starting position to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the objects by\n   * @returns Objects array with the object data\n   */\n  async getAccountOwnedObjects(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;\n  }): Promise<GetObjectDataQueryResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.DEFAULT,\n    });\n    return getAccountOwnedObjects({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Derives an account by providing a private key.\n   * This functions resolves the provided private key type and derives the public key from it.\n   *\n   * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and\n   * auth key using the SingleKey scheme locally.\n   *\n   * If the privateKey is a ED25519 type, it looks up the authentication key on chain, and uses it to resolve\n   * whether it is a Legacy ED25519 key or a Unified ED25519 key. It then derives the account based\n   * on that.\n   *\n   * @example\n   * const account = await aptos.deriveAccountFromPrivateKey({privateKey:new Ed25519PrivateKey(\"0x123\")})\n   *\n   * @param args.privateKey An account private key\n   * @returns Account type\n   */\n  async deriveAccountFromPrivateKey(args: { privateKey: PrivateKey }): Promise<AccountModule> {\n    return deriveAccountFromPrivateKey({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"2OAkDO,IAAMA,EAAN,KAAc,CACnB,YAAqBC,EAAqB,CAArB,YAAAA,CAAsB,CAiB3C,MAAM,eAAeC,EAAqE,CACxF,OAAOC,EAAQ,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CACtD,CAgBA,MAAM,kBAAkBA,EAGU,CAChC,OAAOE,EAAW,CAAE,YAAa,KAAK,OAAQ,GAAGF,CAAK,CAAC,CACzD,CAqBA,MAAM,iBAAiBA,EAIS,CAC9B,OAAOG,EAAU,CAAE,YAAa,KAAK,OAAQ,GAAGH,CAAK,CAAC,CACxD,CAiBA,MAAM,uBAAuBA,EAGM,CACjC,OAAOI,EAAgB,CACrB,YAAa,KAAK,OAClB,GAAGJ,CACL,CAAC,CACH,CAiBA,MAAM,oBAAoBA,EAGE,CAC1B,OAAOK,EAAa,CAAE,YAAa,KAAK,OAAQ,GAAGL,CAAK,CAAC,CAC3D,CAiBA,MAAM,mBAAuCA,EAI9B,CACb,OAAOM,EAAe,CAAE,YAAa,KAAK,OAAQ,GAAGN,CAAK,CAAC,CAC7D,CAeA,MAAM,6BAA6BA,EAIP,CAC1B,OAAOO,EAA6B,CAAE,YAAa,KAAK,OAAQ,GAAGP,CAAK,CAAC,CAC3E,CAYA,MAAM,sBAAsBA,EAGR,CAClB,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,8CACF,CAAC,EACMS,EAAsB,CAC3B,YAAa,KAAK,OAClB,GAAGT,CACL,CAAC,CACH,CAmBA,MAAM,sBAAsBA,EAIoB,CAC9C,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,kCACF,CAAC,EACMU,EAAsB,CAC3B,YAAa,KAAK,OAClB,GAAGV,CACL,CAAC,CACH,CAoBA,MAAM,2CAA2CA,EAKQ,CACvD,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,kCACF,CAAC,EACMW,EAA2C,CAChD,YAAa,KAAK,OAClB,GAAGX,CACL,CAAC,CACH,CAmBA,MAAM,qCAAqCA,EAIc,CACvD,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,kCACF,CAAC,EACMY,EAAqC,CAC1C,YAAa,KAAK,OAClB,GAAGZ,CACL,CAAC,CACH,CAYA,MAAM,4BAA4BA,EAGd,CAClB,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,8CACF,CAAC,EACMa,EAA4B,CACjC,YAAa,KAAK,OAClB,GAAGb,CACL,CAAC,CACH,CAgBA,MAAM,oBAAoBA,EAMe,CACvC,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,wCACF,CAAC,EACMc,EAAoB,CACzB,YAAa,KAAK,OAClB,GAAGd,CACL,CAAC,CACH,CAYA,MAAM,qBAAqBA,EAGP,CAClB,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,wCACF,CAAC,EACMe,EAAqB,CAAE,YAAa,KAAK,OAAQ,GAAGf,CAAK,CAAC,CACnE,CAYA,MAAM,oBAAoBA,EAGN,CAClB,OAAO,KAAK,qBAAqB,CAAE,SAAUgB,EAAY,GAAGhB,CAAK,CAAC,CACpE,CAeA,MAAM,qBAAqBA,EAKP,CAClB,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,wCACF,CAAC,EACMiB,EAAqB,CAAE,YAAa,KAAK,OAAQ,GAAGjB,CAAK,CAAC,CACnE,CAeA,MAAM,uBAAuBA,EAIW,CACtC,aAAMQ,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBR,EAAK,qBAC3B,iCACF,CAAC,EACMkB,EAAuB,CAC5B,YAAa,KAAK,OAClB,GAAGlB,CACL,CAAC,CACH,CAmBA,MAAM,4BAA4BA,EAA0D,CAC1F,OAAOmB,EAA4B,CAAE,YAAa,KAAK,OAAQ,GAAGnB,CAAK,CAAC,CAC1E,CACF","names":["Account","config","args","getInfo","getModules","getModule","getTransactions","getResources","getResource","lookupOriginalAccountAddress","waitForIndexerOnVersion","getAccountTokensCount","getAccountOwnedTokens","getAccountOwnedTokensFromCollectionAddress","getAccountCollectionsWithOwnedTokens","getAccountTransactionsCount","getAccountCoinsData","getAccountCoinsCount","APTOS_COIN","getAccountCoinAmount","getAccountOwnedObjects","deriveAccountFromPrivateKey"]}

package/dist/esm/chunk-EZIF26UH.mjs

@@ -1,2 +0,0 @@
-import{a as y}from"./chunk-RA3YPQG2.mjs";import{e as o}from"./chunk-Q67DUNMI.mjs";import{a as g,b as u}from"./chunk-6ERHGCK2.mjs";var l=class a{constructor(i){let{multiKey:s,signers:e}=i;this.publicKey=s,this.signingScheme=3,this.accountAddress=this.publicKey.authKey().derivedAddress();let r=[];for(let t of e)r.push(this.publicKey.getIndex(t.publicKey));let n=e.map((t,c)=>[t,r[c]]);n.sort((t,c)=>t[1]-c[1]),this.signers=n.map(t=>t[0]),this.signerIndicies=n.map(t=>t[1]),this.signaturesBitmap=this.publicKey.createBitmap({bits:r})}static fromPublicKeysAndSigners(i){let{publicKeys:s,signaturesRequired:e,signers:r}=i,n=new g({publicKeys:s,signaturesRequired:e});return new a({multiKey:n,signers:r})}static isMultiKeySigner(i){return i instanceof a}signWithAuthenticator(i){return new o(this.publicKey,this.sign(i))}signTransactionWithAuthenticator(i){return new o(this.publicKey,this.signTransaction(i))}async waitForProofFetch(){let s=this.signers.filter(e=>e instanceof y).map(async e=>e.waitForProofFetch());await Promise.all(s)}sign(i){let s=[];for(let e of this.signers)s.push(e.sign(i));return new u({signatures:s,bitmap:this.signaturesBitmap})}signTransaction(i){let s=[];for(let e of this.signers)s.push(e.signTransaction(i));return new u({signatures:s,bitmap:this.signaturesBitmap})}verifySignature(i){let{message:s,signature:e}=i;if(!this.signerIndicies.every((n,t)=>t===0||n>=this.signerIndicies[t-1]))return!1;for(let n=0;n<e.signatures.length;n+=1){let t=e.signatures[n];if(!this.publicKey.publicKeys[this.signerIndicies[n]].verifySignature({message:s,signature:t}))return!1}return!0}};export{l as a};
-//# sourceMappingURL=chunk-EZIF26UH.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/MultiKeyAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Account } from \"./Account\";\nimport { MultiKey, MultiKeySignature, PublicKey } from \"../core/crypto\";\nimport { AccountAddress } from \"../core/accountAddress\";\nimport { HexInput, SigningScheme } from \"../types\";\nimport { AccountAuthenticatorMultiKey } from \"../transactions/authenticator/account\";\nimport { AnyRawTransaction } from \"../transactions/types\";\nimport { KeylessAccount } from \"./KeylessAccount\";\n\nexport interface VerifyMultiKeySignatureArgs {\n  message: HexInput;\n  signature: MultiKeySignature;\n}\n\n/**\n * Signer implementation for the MultiKey authentication scheme.\n *\n * This accounts to use a M of N signing scheme. M and N are specified in the {@link MultiKey}\n * It signs messages via the array of M number of Accounts that individually correspond to a public key in the {@link MultiKey}.\n *\n * Note: Generating a signer instance does not create the account on-chain.\n */\nexport class MultiKeyAccount implements Account {\n  /**\n   * Public key associated with the account\n   */\n  readonly publicKey: MultiKey;\n\n  /**\n   * Account address associated with the account\n   */\n  readonly accountAddress: AccountAddress;\n\n  /**\n   * Signing scheme used to sign transactions\n   */\n  readonly signingScheme: SigningScheme;\n\n  /**\n   * The signers used to sign messages.  These signers should correspond to public keys in the\n   * MultiKeyAccount's public key.  The number of signers should be equal or greater\n   * than this.publicKey.signaturesRequired\n   */\n  readonly signers: Account[];\n\n  /**\n   * An array of indicies where for signer[i], signerIndicies[i] is the index of the corresponding public key in\n   * publicKey.publicKeys.  Used to derive the right public key to use for verification.\n   */\n  readonly signerIndicies: number[];\n\n  readonly signaturesBitmap: Uint8Array;\n\n  /**\n   * constructor for MultiKeyAccount\n   *\n   * @param args.multiKey the multikey of the account which consists of N public keys and a number M which is\n   * the number of required signatures.\n   * @param args.signers an array of M signers that will be used to sign the transaction\n   * @returns MultiKeyAccount\n   */\n  constructor(args: { multiKey: MultiKey; signers: Account[] }) {\n    const { multiKey, signers } = args;\n\n    this.publicKey = multiKey;\n    this.signingScheme = SigningScheme.MultiKey;\n\n    this.accountAddress = this.publicKey.authKey().derivedAddress();\n\n    // Get the index of each respective signer in the bitmap\n    const bitPositions: number[] = [];\n    for (const signer of signers) {\n      bitPositions.push(this.publicKey.getIndex(signer.publicKey));\n    }\n    // Zip signers and bit positions and sort signers by bit positions in order\n    // to ensure the signature is signed in ascending order according to the bitmap.\n    // Authentication on chain will fail otherwise.\n    const signersAndBitPosition: [Account, number][] = signers.map((signer, index) => [signer, bitPositions[index]]);\n    signersAndBitPosition.sort((a, b) => a[1] - b[1]);\n    this.signers = signersAndBitPosition.map((value) => value[0]);\n    this.signerIndicies = signersAndBitPosition.map((value) => value[1]);\n    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });\n  }\n\n  /**\n   * Static constructor for MultiKeyAccount\n   *\n   * @param args.publicKeys the N public keys of the MultiKeyAccount\n   * @param args.signaturesRequired the number of signatures required\n   * @param args.signers an array of M signers that will be used to sign the transaction\n   * @returns MultiKeyAccount\n   */\n  static fromPublicKeysAndSigners(args: {\n    publicKeys: PublicKey[];\n    signaturesRequired: number;\n    signers: Account[];\n  }): MultiKeyAccount {\n    const { publicKeys, signaturesRequired, signers } = args;\n    const multiKey = new MultiKey({ publicKeys, signaturesRequired });\n    return new MultiKeyAccount({ multiKey, signers });\n  }\n\n  static isMultiKeySigner(account: Account): account is MultiKeyAccount {\n    return account instanceof MultiKeyAccount;\n  }\n\n  /**\n   * Sign a message using the account's signers.\n   * @param message the signing message, as binary input\n   * @return the AccountAuthenticator containing the signature, together with the account's public key\n   */\n  signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiKey {\n    return new AccountAuthenticatorMultiKey(this.publicKey, this.sign(message));\n  }\n\n  /**\n   * Sign a transaction using the account's signers.\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): AccountAuthenticatorMultiKey {\n    return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));\n  }\n\n  /**\n   * Waits for any proofs on any KeylessAccount signers to be fetched. If the proof is fetched a syncronously, call this\n   * to ensure signing with the KeylessAccount does not fail as the proof must be ready.\n   * @return\n   */\n  async waitForProofFetch() {\n    const keylessSigners = this.signers.filter((signer) => signer instanceof KeylessAccount) as KeylessAccount[];\n    const promises = keylessSigners.map(async (signer) => signer.waitForProofFetch());\n    await Promise.all(promises);\n  }\n\n  /**\n   * Sign the given message using the MultiKeyAccount's signers\n   * @param message in HexInput format\n   * @returns MultiKeySignature\n   */\n  sign(data: HexInput): MultiKeySignature {\n    const signatures = [];\n    for (const signer of this.signers) {\n      signatures.push(signer.sign(data));\n    }\n    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });\n  }\n\n  /**\n   * Sign the given transaction using the MultiKeyAccount's signers\n   * @param transaction the transaction to be signed\n   * @returns MultiKeySignature\n   */\n  signTransaction(transaction: AnyRawTransaction): MultiKeySignature {\n    const signatures = [];\n    for (const signer of this.signers) {\n      signatures.push(signer.signTransaction(transaction));\n    }\n    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });\n  }\n\n  /**\n   * Verify the given message and signature with the public key.\n   *\n   * @param args.message raw message data in HexInput format\n   * @param args.signatures signed message MultiKeySignature\n   * @returns boolean\n   */\n  verifySignature(args: VerifyMultiKeySignatureArgs): boolean {\n    const { message, signature } = args;\n    const isSignerIndiciesSorted = this.signerIndicies.every(\n      (value, i) => i === 0 || value >= this.signerIndicies[i - 1],\n    );\n    if (!isSignerIndiciesSorted) {\n      return false;\n    }\n    for (let i = 0; i < signature.signatures.length; i += 1) {\n      const singleSignature = signature.signatures[i];\n      const publicKey = this.publicKey.publicKeys[this.signerIndicies[i]];\n      if (!publicKey.verifySignature({ message, signature: singleSignature })) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n"],"mappings":"kIAwBO,IAAMA,EAAN,MAAMC,CAAmC,CAuC9C,YAAYC,EAAkD,CAC5D,GAAM,CAAE,SAAAC,EAAU,QAAAC,CAAQ,EAAIF,EAE9B,KAAK,UAAYC,EACjB,KAAK,cAAgB,EAErB,KAAK,eAAiB,KAAK,UAAU,QAAQ,EAAE,eAAe,EAG9D,IAAME,EAAyB,CAAC,EAChC,QAAWC,KAAUF,EACnBC,EAAa,KAAK,KAAK,UAAU,SAASC,EAAO,SAAS,CAAC,EAK7D,IAAMC,EAA6CH,EAAQ,IAAI,CAACE,EAAQE,IAAU,CAACF,EAAQD,EAAaG,CAAK,CAAC,CAAC,EAC/GD,EAAsB,KAAK,CAACE,EAAGC,IAAMD,EAAE,CAAC,EAAIC,EAAE,CAAC,CAAC,EAChD,KAAK,QAAUH,EAAsB,IAAKI,GAAUA,EAAM,CAAC,CAAC,EAC5D,KAAK,eAAiBJ,EAAsB,IAAKI,GAAUA,EAAM,CAAC,CAAC,EACnE,KAAK,iBAAmB,KAAK,UAAU,aAAa,CAAE,KAAMN,CAAa,CAAC,CAC5E,CAUA,OAAO,yBAAyBH,EAIZ,CAClB,GAAM,CAAE,WAAAU,EAAY,mBAAAC,EAAoB,QAAAT,CAAQ,EAAIF,EAC9CC,EAAW,IAAIW,EAAS,CAAE,WAAAF,EAAY,mBAAAC,CAAmB,CAAC,EAChE,OAAO,IAAIZ,EAAgB,CAAE,SAAAE,EAAU,QAAAC,CAAQ,CAAC,CAClD,CAEA,OAAO,iBAAiBW,EAA8C,CACpE,OAAOA,aAAmBd,CAC5B,CAOA,sBAAsBe,EAAiD,CACrE,OAAO,IAAIC,EAA6B,KAAK,UAAW,KAAK,KAAKD,CAAO,CAAC,CAC5E,CAOA,iCAAiCE,EAA8D,CAC7F,OAAO,IAAID,EAA6B,KAAK,UAAW,KAAK,gBAAgBC,CAAW,CAAC,CAC3F,CAOA,MAAM,mBAAoB,CAExB,IAAMC,EADiB,KAAK,QAAQ,OAAQb,GAAWA,aAAkBc,CAAc,EACvD,IAAI,MAAOd,GAAWA,EAAO,kBAAkB,CAAC,EAChF,MAAM,QAAQ,IAAIa,CAAQ,CAC5B,CAOA,KAAKE,EAAmC,CACtC,IAAMC,EAAa,CAAC,EACpB,QAAWhB,KAAU,KAAK,QACxBgB,EAAW,KAAKhB,EAAO,KAAKe,CAAI,CAAC,EAEnC,OAAO,IAAIE,EAAkB,CAAE,WAAAD,EAAY,OAAQ,KAAK,gBAAiB,CAAC,CAC5E,CAOA,gBAAgBJ,EAAmD,CACjE,IAAMI,EAAa,CAAC,EACpB,QAAWhB,KAAU,KAAK,QACxBgB,EAAW,KAAKhB,EAAO,gBAAgBY,CAAW,CAAC,EAErD,OAAO,IAAIK,EAAkB,CAAE,WAAAD,EAAY,OAAQ,KAAK,gBAAiB,CAAC,CAC5E,CASA,gBAAgBpB,EAA4C,CAC1D,GAAM,CAAE,QAAAc,EAAS,UAAAQ,CAAU,EAAItB,EAI/B,GAAI,CAH2B,KAAK,eAAe,MACjD,CAACS,EAAOc,IAAMA,IAAM,GAAKd,GAAS,KAAK,eAAec,EAAI,CAAC,CAC7D,EAEE,MAAO,GAET,QAASA,EAAI,EAAGA,EAAID,EAAU,WAAW,OAAQC,GAAK,EAAG,CACvD,IAAMC,EAAkBF,EAAU,WAAWC,CAAC,EAE9C,GAAI,CADc,KAAK,UAAU,WAAW,KAAK,eAAeA,CAAC,CAAC,EACnD,gBAAgB,CAAE,QAAAT,EAAS,UAAWU,CAAgB,CAAC,EACpE,MAAO,EAEX,CACA,MAAO,EACT,CACF","names":["MultiKeyAccount","_MultiKeyAccount","args","multiKey","signers","bitPositions","signer","signersAndBitPosition","index","a","b","value","publicKeys","signaturesRequired","MultiKey","account","message","AccountAuthenticatorMultiKey","transaction","promises","KeylessAccount","data","signatures","MultiKeySignature","signature","i","singleSignature"]}