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

package/dist/esm/chunk-FH6RKWVF.mjs

@@ -1,72 +0,0 @@
-import {
-  queryIndexer
-} from "./chunk-I5BTSNTY.mjs";
-import {
-  GetEvents
-} from "./chunk-NFA2AU5E.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-
-// src/internal/event.ts
-var MAX_EVENT_TYPE_LENGTH = 300;
-var checkEventTypeLength = (eventType) => {
-  if (eventType && eventType.length > MAX_EVENT_TYPE_LENGTH) {
-    throw new Error(`Event type length exceeds the maximum length of ${MAX_EVENT_TYPE_LENGTH}`);
-  }
-};
-async function getModuleEventsByEventType(args) {
-  const { aptosConfig, eventType, options } = args;
-  const whereCondition = {
-    account_address: { _eq: "0x0000000000000000000000000000000000000000000000000000000000000000" },
-    creation_number: { _eq: "0" },
-    sequence_number: { _eq: "0" },
-    indexed_type: { _eq: eventType }
-  };
-  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });
-}
-async function getAccountEventsByCreationNumber(args) {
-  const { accountAddress, aptosConfig, creationNumber, options } = args;
-  const address = AccountAddress.from(accountAddress);
-  const whereCondition = {
-    account_address: { _eq: address.toStringLong() },
-    creation_number: { _eq: creationNumber }
-  };
-  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });
-}
-async function getAccountEventsByEventType(args) {
-  const { accountAddress, aptosConfig, eventType, options } = args;
-  const address = AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    account_address: { _eq: address },
-    indexed_type: { _eq: eventType }
-  };
-  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });
-}
-async function getEvents(args) {
-  const { aptosConfig, options } = args;
-  checkEventTypeLength(options?.where?.indexed_type?._eq);
-  const graphqlQuery = {
-    query: GetEvents,
-    variables: {
-      where_condition: options?.where,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.orderBy
-    }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getEvents"
-  });
-  return data.events;
-}
-
-export {
-  getModuleEventsByEventType,
-  getAccountEventsByCreationNumber,
-  getAccountEventsByEventType,
-  getEvents
-};
-//# sourceMappingURL=chunk-FH6RKWVF.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/event.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file contains the underlying implementations for exposed API surface in\n * the {@link api/event}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * event namespace and without having a dependency cycle error.\n */\n\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { AccountAddress, AccountAddressInput } from \"../core\";\nimport { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructId, OrderByArg, WhereArg } from \"../types\";\nimport { GetEventsQuery } from \"../types/generated/operations\";\nimport { GetEvents } from \"../types/generated/queries\";\nimport { EventsBoolExp, InputMaybe } from \"../types/generated/types\";\nimport { queryIndexer } from \"./general\";\n\nconst MAX_EVENT_TYPE_LENGTH = 300;\nconst checkEventTypeLength = (eventType?: InputMaybe<string>) => {\n  if (eventType && eventType.length > MAX_EVENT_TYPE_LENGTH) {\n    throw new Error(`Event type length exceeds the maximum length of ${MAX_EVENT_TYPE_LENGTH}`);\n  }\n};\n\nexport async function getModuleEventsByEventType(args: {\n  aptosConfig: AptosConfig;\n  eventType: MoveStructId;\n  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;\n}): Promise<GetEventsResponse> {\n  const { aptosConfig, eventType, options } = args;\n\n  const whereCondition: EventsBoolExp = {\n    account_address: { _eq: \"0x0000000000000000000000000000000000000000000000000000000000000000\" },\n    creation_number: { _eq: \"0\" },\n    sequence_number: { _eq: \"0\" },\n    indexed_type: { _eq: eventType },\n  };\n\n  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });\n}\n\nexport async function getAccountEventsByCreationNumber(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  creationNumber: AnyNumber;\n  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;\n}): Promise<GetEventsResponse> {\n  const { accountAddress, aptosConfig, creationNumber, options } = args;\n  const address = AccountAddress.from(accountAddress);\n\n  const whereCondition: EventsBoolExp = {\n    account_address: { _eq: address.toStringLong() },\n    creation_number: { _eq: creationNumber },\n  };\n\n  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });\n}\n\nexport async function getAccountEventsByEventType(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  eventType: MoveStructId;\n  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;\n}): Promise<GetEventsResponse> {\n  const { accountAddress, aptosConfig, eventType, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: EventsBoolExp = {\n    account_address: { _eq: address },\n    indexed_type: { _eq: eventType },\n  };\n\n  return getEvents({ aptosConfig, options: { ...options, where: whereCondition } });\n}\n\nexport async function getEvents(args: {\n  aptosConfig: AptosConfig;\n  options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;\n}): Promise<GetEventsResponse> {\n  const { aptosConfig, options } = args;\n  // eslint-disable-next-line no-underscore-dangle\n  checkEventTypeLength(options?.where?.indexed_type?._eq);\n\n  const graphqlQuery = {\n    query: GetEvents,\n    variables: {\n      where_condition: options?.where,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetEventsQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getEvents\",\n  });\n\n  return data.events;\n}\n"],"mappings":";;;;;;;;;;;AAkBA,IAAM,wBAAwB;AAC9B,IAAM,uBAAuB,CAAC,cAAmC;AAC/D,MAAI,aAAa,UAAU,SAAS,uBAAuB;AACzD,UAAM,IAAI,MAAM,mDAAmD,qBAAqB,EAAE;AAAA,EAC5F;AACF;AAEA,eAAsB,2BAA2B,MAIlB;AAC7B,QAAM,EAAE,aAAa,WAAW,QAAQ,IAAI;AAE5C,QAAM,iBAAgC;AAAA,IACpC,iBAAiB,EAAE,KAAK,qEAAqE;AAAA,IAC7F,iBAAiB,EAAE,KAAK,IAAI;AAAA,IAC5B,iBAAiB,EAAE,KAAK,IAAI;AAAA,IAC5B,cAAc,EAAE,KAAK,UAAU;AAAA,EACjC;AAEA,SAAO,UAAU,EAAE,aAAa,SAAS,EAAE,GAAG,SAAS,OAAO,eAAe,EAAE,CAAC;AAClF;AAEA,eAAsB,iCAAiC,MAKxB;AAC7B,QAAM,EAAE,gBAAgB,aAAa,gBAAgB,QAAQ,IAAI;AACjE,QAAM,UAAU,eAAe,KAAK,cAAc;AAElD,QAAM,iBAAgC;AAAA,IACpC,iBAAiB,EAAE,KAAK,QAAQ,aAAa,EAAE;AAAA,IAC/C,iBAAiB,EAAE,KAAK,eAAe;AAAA,EACzC;AAEA,SAAO,UAAU,EAAE,aAAa,SAAS,EAAE,GAAG,SAAS,OAAO,eAAe,EAAE,CAAC;AAClF;AAEA,eAAsB,4BAA4B,MAKnB;AAC7B,QAAM,EAAE,gBAAgB,aAAa,WAAW,QAAQ,IAAI;AAC5D,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAEjE,QAAM,iBAAgC;AAAA,IACpC,iBAAiB,EAAE,KAAK,QAAQ;AAAA,IAChC,cAAc,EAAE,KAAK,UAAU;AAAA,EACjC;AAEA,SAAO,UAAU,EAAE,aAAa,SAAS,EAAE,GAAG,SAAS,OAAO,eAAe,EAAE,CAAC;AAClF;AAEA,eAAsB,UAAU,MAGD;AAC7B,QAAM,EAAE,aAAa,QAAQ,IAAI;AAEjC,uBAAqB,SAAS,OAAO,cAAc,GAAG;AAEtD,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB,SAAS;AAAA,MAC1B,QAAQ,SAAS;AAAA,MACjB,OAAO,SAAS;AAAA,MAChB,UAAU,SAAS;AAAA,IACrB;AAAA,EACF;AAEA,QAAM,OAAO,MAAM,aAA6B;AAAA,IAC9C;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,SAAO,KAAK;AACd;","names":[]}

package/dist/esm/chunk-G2VEDGO7.mjs

@@ -1,15 +0,0 @@
-import {
-  Deserializer
-} from "./chunk-6J7C4S3H.mjs";
-
-// src/utils/normalizeBundle.ts
-function normalizeBundle(cls, value) {
-  const serializedBytes = value.bcsToBytes();
-  const deserializer = new Deserializer(serializedBytes);
-  return cls.deserialize(deserializer);
-}
-
-export {
-  normalizeBundle
-};
-//# sourceMappingURL=chunk-G2VEDGO7.mjs.map

package/dist/esm/chunk-GDE3IBAB.mjs

@@ -1,126 +0,0 @@
-import {
-  generateSigningMessageForTransaction
-} from "./chunk-LMUNGBGS.mjs";
-import {
-  AccountAuthenticatorSingleKey
-} from "./chunk-MQALTYRJ.mjs";
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-NYELBSVO.mjs";
-import {
-  Secp256k1PrivateKey
-} from "./chunk-SRKSXJ5U.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-B673XLJY.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-
-// src/account/SingleKeyAccount.ts
-var SingleKeyAccount = class _SingleKeyAccount {
-  // region Constructors
-  constructor(args) {
-    this.signingScheme = 2 /* SingleKey */;
-    const { privateKey, address } = args;
-    this.privateKey = privateKey;
-    this.publicKey = new AnyPublicKey(privateKey.publicKey());
-    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
-  }
-  /**
-   * Derives an account from a randomly generated private key.
-   * Default generation is using an Ed25519 key
-   * @returns Account with the given signature scheme
-   */
-  static generate(args = {}) {
-    const { scheme = 0 /* Ed25519 */ } = args;
-    let privateKey;
-    switch (scheme) {
-      case 0 /* Ed25519 */:
-        privateKey = Ed25519PrivateKey.generate();
-        break;
-      case 2 /* Secp256k1Ecdsa */:
-        privateKey = Secp256k1PrivateKey.generate();
-        break;
-      default:
-        throw new Error(`Unsupported signature scheme ${scheme}`);
-    }
-    return new _SingleKeyAccount({ privateKey });
-  }
-  /**
-   * Derives an account with bip44 path and mnemonics,
-   * Default to using an Ed25519 signature scheme.
-   *
-   * @param args.scheme The signature scheme to derive the private key with
-   * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
-   * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
-   * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-   * @param args.mnemonic the mnemonic seed phrase of the account
-   */
-  static fromDerivationPath(args) {
-    const { scheme = 0 /* Ed25519 */, path, mnemonic } = args;
-    let privateKey;
-    switch (scheme) {
-      case 0 /* Ed25519 */:
-        privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);
-        break;
-      case 2 /* Secp256k1Ecdsa */:
-        privateKey = Secp256k1PrivateKey.fromDerivationPath(path, mnemonic);
-        break;
-      default:
-        throw new Error(`Unsupported signature scheme ${scheme}`);
-    }
-    return new _SingleKeyAccount({ privateKey });
-  }
-  // endregion
-  // region Account
-  /**
-   * Verify the given message and signature with the public key.
-   *
-   * @param args.message raw message data in HexInput format
-   * @param args.signature signed message Signature
-   * @returns
-   */
-  verifySignature(args) {
-    return this.publicKey.verifySignature(args);
-  }
-  /**
-   * Sign a message using the account's private key.
-   * @param message the signing message, as binary input
-   * @return the AccountAuthenticator containing the signature, together with the account's public key
-   */
-  signWithAuthenticator(message) {
-    return new AccountAuthenticatorSingleKey(this.publicKey, this.sign(message));
-  }
-  /**
-   * Sign a transaction using the account's private key.
-   * @param transaction the raw transaction
-   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
-   */
-  signTransactionWithAuthenticator(transaction) {
-    return new AccountAuthenticatorSingleKey(this.publicKey, this.signTransaction(transaction));
-  }
-  /**
-   * Sign the given message using the account's private key.
-   * @param message in HexInput format
-   * @returns Signature
-   */
-  sign(message) {
-    return new AnySignature(this.privateKey.sign(message));
-  }
-  /**
-   * Sign the given transaction using the account's private key.
-   * @param transaction the transaction to be signed
-   * @returns Signature
-   */
-  signTransaction(transaction) {
-    return this.sign(generateSigningMessageForTransaction(transaction));
-  }
-  // endregion
-};
-
-export {
-  SingleKeyAccount
-};
-//# sourceMappingURL=chunk-GDE3IBAB.mjs.map

package/dist/esm/chunk-GKF3HFY2.mjs

@@ -1,232 +0,0 @@
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-B673XLJY.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-L3E7YJBM.mjs";
-import {
-  Signature
-} from "./chunk-6BI4XTJN.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-ANOJYMO2.mjs";
-
-// src/core/crypto/multiEd25519.ts
-var _MultiEd25519PublicKey = class _MultiEd25519PublicKey extends AccountPublicKey {
-  /**
-   * Public key for a K-of-N multi-sig transaction. A K-of-N multi-sig transaction means that for such a
-   * transaction to be executed, at least K out of the N authorized signers have signed the transaction
-   * and passed the check conducted by the chain.
-   *
-   * @see {@link
-   * https://aptos.dev/integration/creating-a-signed-transaction/ | Creating a Signed Transaction}
-   *
-   * @param args.publicKeys A list of public keys
-   * @param args.threshold At least "threshold" signatures must be valid
-   */
-  constructor(args) {
-    super();
-    const { publicKeys, threshold } = args;
-    if (publicKeys.length > _MultiEd25519PublicKey.MAX_KEYS || publicKeys.length < _MultiEd25519PublicKey.MIN_KEYS) {
-      throw new Error(
-        `Must have between ${_MultiEd25519PublicKey.MIN_KEYS} and ${_MultiEd25519PublicKey.MAX_KEYS} public keys, inclusive`
-      );
-    }
-    if (threshold < _MultiEd25519PublicKey.MIN_THRESHOLD || threshold > publicKeys.length) {
-      throw new Error(
-        `Threshold must be between ${_MultiEd25519PublicKey.MIN_THRESHOLD} and ${publicKeys.length}, inclusive`
-      );
-    }
-    this.publicKeys = publicKeys;
-    this.threshold = threshold;
-  }
-  // region AccountPublicKey
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (!(signature instanceof MultiEd25519Signature)) {
-      return false;
-    }
-    const indices = [];
-    for (let i = 0; i < 4; i += 1) {
-      for (let j = 0; j < 8; j += 1) {
-        const bitIsSet = (signature.bitmap[i] & 1 << 7 - j) !== 0;
-        if (bitIsSet) {
-          const index = i * 8 + j;
-          indices.push(index);
-        }
-      }
-    }
-    if (indices.length !== signature.signatures.length) {
-      throw new Error("Bitmap and signatures length mismatch");
-    }
-    if (indices.length < this.threshold) {
-      throw new Error("Not enough signatures");
-    }
-    for (let i = 0; i < indices.length; i += 1) {
-      const publicKey = this.publicKeys[indices[i]];
-      if (!publicKey.verifySignature({ message, signature: signature.signatures[i] })) {
-        return false;
-      }
-    }
-    return true;
-  }
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 1 /* MultiEd25519 */,
-      input: this.toUint8Array()
-    });
-  }
-  /**
-   * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold
-   */
-  toUint8Array() {
-    const bytes = new Uint8Array(this.publicKeys.length * Ed25519PublicKey.LENGTH + 1);
-    this.publicKeys.forEach((k, i) => {
-      bytes.set(k.toUint8Array(), i * Ed25519PublicKey.LENGTH);
-    });
-    bytes[this.publicKeys.length * Ed25519PublicKey.LENGTH] = this.threshold;
-    return bytes;
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    const threshold = bytes[bytes.length - 1];
-    const keys = [];
-    for (let i = 0; i < bytes.length - 1; i += Ed25519PublicKey.LENGTH) {
-      const begin = i;
-      keys.push(new Ed25519PublicKey(bytes.subarray(begin, begin + Ed25519PublicKey.LENGTH)));
-    }
-    return new _MultiEd25519PublicKey({ publicKeys: keys, threshold });
-  }
-  // endregion
-};
-/**
- * Maximum number of public keys supported
- */
-_MultiEd25519PublicKey.MAX_KEYS = 32;
-/**
- * Minimum number of public keys needed
- */
-_MultiEd25519PublicKey.MIN_KEYS = 2;
-/**
- * Minimum threshold for the number of valid signatures required
- */
-_MultiEd25519PublicKey.MIN_THRESHOLD = 1;
-var MultiEd25519PublicKey = _MultiEd25519PublicKey;
-var _MultiEd25519Signature = class _MultiEd25519Signature extends Signature {
-  /**
-   * Signature for a K-of-N multi-sig transaction.
-   *
-   * @see {@link
-   * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}
-   *
-   * @param args.signatures A list of signatures
-   * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth
-   * signature should be provided in `signatures`. Bits are read from left to right.
-   * Alternatively, you can specify an array of bitmap positions.
-   * Valid position should range between 0 and 31.
-   * @see MultiEd25519Signature.createBitmap
-   */
-  constructor(args) {
-    super();
-    const { signatures, bitmap } = args;
-    if (signatures.length > _MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {
-      throw new Error(
-        `The number of signatures cannot be greater than ${_MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED}`
-      );
-    }
-    this.signatures = signatures;
-    if (!(bitmap instanceof Uint8Array)) {
-      this.bitmap = _MultiEd25519Signature.createBitmap({ bits: bitmap });
-    } else if (bitmap.length !== _MultiEd25519Signature.BITMAP_LEN) {
-      throw new Error(`"bitmap" length should be ${_MultiEd25519Signature.BITMAP_LEN}`);
-    } else {
-      this.bitmap = bitmap;
-    }
-  }
-  // region AccountSignature
-  /**
-   * Converts a MultiSignature into Uint8Array (bytes) with `bytes = s1_bytes | ... | sn_bytes | bitmap`
-   */
-  toUint8Array() {
-    const bytes = new Uint8Array(this.signatures.length * Ed25519Signature.LENGTH + _MultiEd25519Signature.BITMAP_LEN);
-    this.signatures.forEach((k, i) => {
-      bytes.set(k.toUint8Array(), i * Ed25519Signature.LENGTH);
-    });
-    bytes.set(this.bitmap, this.signatures.length * Ed25519Signature.LENGTH);
-    return bytes;
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    const bitmap = bytes.subarray(bytes.length - 4);
-    const signatures = [];
-    for (let i = 0; i < bytes.length - bitmap.length; i += Ed25519Signature.LENGTH) {
-      const begin = i;
-      signatures.push(new Ed25519Signature(bytes.subarray(begin, begin + Ed25519Signature.LENGTH)));
-    }
-    return new _MultiEd25519Signature({ signatures, bitmap });
-  }
-  // endregion
-  /**
-   * Helper method to create a bitmap out of the specified bit positions
-   * @param args.bits The bitmap positions that should be set. A position starts at index 0.
-   * Valid position should range between 0 and 31.
-   * @example
-   * Here's an example of valid `bits`
-   * ```
-   * [0, 2, 31]
-   * ```
-   * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.
-   * The result bitmap should be 0b1010000000000000000000000000001
-   *
-   * @returns bitmap that is 32bit long
-   */
-  static createBitmap(args) {
-    const { bits } = args;
-    const firstBitInByte = 128;
-    const bitmap = new Uint8Array([0, 0, 0, 0]);
-    const dupCheckSet = /* @__PURE__ */ new Set();
-    bits.forEach((bit, index) => {
-      if (bit >= _MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {
-        throw new Error(`Cannot have a signature larger than ${_MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED - 1}.`);
-      }
-      if (dupCheckSet.has(bit)) {
-        throw new Error("Duplicate bits detected.");
-      }
-      if (index > 0 && bit <= bits[index - 1]) {
-        throw new Error("The bits need to be sorted in ascending order.");
-      }
-      dupCheckSet.add(bit);
-      const byteOffset = Math.floor(bit / 8);
-      let byte = bitmap[byteOffset];
-      byte |= firstBitInByte >> bit % 8;
-      bitmap[byteOffset] = byte;
-    });
-    return bitmap;
-  }
-};
-/**
- * Maximum number of Ed25519 signatures supported
- */
-_MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED = 32;
-/**
- * Number of bytes in the bitmap representing who signed the transaction (32-bits)
- */
-_MultiEd25519Signature.BITMAP_LEN = 4;
-var MultiEd25519Signature = _MultiEd25519Signature;
-
-export {
-  MultiEd25519PublicKey,
-  MultiEd25519Signature
-};
-//# sourceMappingURL=chunk-GKF3HFY2.mjs.map

package/dist/esm/chunk-GMGJ6Q5P.mjs

@@ -1,166 +0,0 @@
-import {
-  getCurrentFungibleAssetBalances,
-  getFungibleAssetActivities,
-  getFungibleAssetMetadata,
-  transferFungibleAsset
-} from "./chunk-ZZA2BSOF.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-PSRD6U34.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-
-// src/api/fungibleAsset.ts
-var FungibleAsset = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Queries all fungible asset metadata.
-   *
-   * @example
-   * const fungibleAsset = await aptos.getFungibleAssetMetadata()
-   *
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @param args.options Optional configuration for pagination and filtering
-   *
-   * @returns A list of fungible asset metadata
-   */
-  async getFungibleAssetMetadata(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
-    });
-    return getFungibleAssetMetadata({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries a fungible asset metadata by the asset type
-   *
-   * This query returns the fungible asset metadata for a specific fungible asset.
-   *
-   * @example
-   * const fungibleAsset = await aptos.getFungibleAssetMetadataByAssetType({assetType:"0x123::test_coin::TestCoin"})
-   *
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @param args.assetType The asset type of the fungible asset.
-   * e.g
-   * "0x1::aptos_coin::AptosCoin" for Aptos Coin
-   * "0xc2948283c2ce03aafbb294821de7ee684b06116bb378ab614fa2de07a99355a8" - address format if this is fungible asset
-   *
-   * @returns A fungible asset metadata item
-   */
-  async getFungibleAssetMetadataByAssetType(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
-    });
-    const data = await getFungibleAssetMetadata({
-      aptosConfig: this.config,
-      options: {
-        where: {
-          asset_type: { _eq: args.assetType }
-        }
-      }
-    });
-    return data[0];
-  }
-  /**
-   * Queries a fungible asset metadata by the creator address
-   *
-   * This query returns the fungible asset metadata for a specific fungible asset.
-   *
-   * @example
-   * const fungibleAsset = await aptos.getFungibleAssetMetadataByCreatorAddress({creatorAddress:"0x123"})
-   *
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @param args.creatorAddress The creator address of the fungible asset.
-   *
-   * @returns A fungible asset metadata item
-   */
-  async getFungibleAssetMetadataByCreatorAddress(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
-    });
-    const data = await getFungibleAssetMetadata({
-      aptosConfig: this.config,
-      options: {
-        where: {
-          creator_address: { _eq: AccountAddress.from(args.creatorAddress).toStringLong() }
-        }
-      }
-    });
-    return data;
-  }
-  /**
-   * Queries all fungible asset activities
-   *
-   * @example
-   * const fungibleAssetActivities = await aptos.getFungibleAssetActivities()
-   *
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @param args.options Optional configuration for pagination and filtering
-   *
-   * @returns A list of fungible asset metadata
-   */
-  async getFungibleAssetActivities(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
-    });
-    return getFungibleAssetActivities({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries all fungible asset balances
-   *
-   * @example
-   * const fungibleAssetBalances = await aptos.getCurrentFungibleAssetBalances()
-   *
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @param args.options Optional configuration for pagination and filtering
-   *
-   * @returns A list of fungible asset metadata
-   */
-  async getCurrentFungibleAssetBalances(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
-    });
-    return getCurrentFungibleAssetBalances({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Transfer `amount` of fungible asset from sender's primary store to recipient's primary store.
-   *
-   * Use this method to transfer any fungible asset including fungible token.
-   *
-   * @example
-   * const transaction = await aptos.transferFungibleAsset({
-   *  sender: alice,
-   *  fungibleAssetMetadataAddress: "0x123",
-   *  recipient: "0x456",
-   *  amount: 5
-   * })
-   *
-   * @param sender The sender account
-   * @param fungibleAssetMetadataAddress The fungible asset account address.
-   * For example if you’re transferring USDT this would be the USDT address
-   * @param recipient The recipient account address
-   * @param amount Number of assets to transfer
-   *
-   * @returns A SimpleTransaction that can be simulated or submitted to chain.
-   */
-  async transferFungibleAsset(args) {
-    return transferFungibleAsset({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  FungibleAsset
-};
-//# sourceMappingURL=chunk-GMGJ6Q5P.mjs.map