@aptos-labs/ts-sdk 1.14.0-zeta.2 → 1.14.0-zeta.4

package/dist/esm/chunk-VZQXLVEP.mjs

@@ -1,197 +0,0 @@
-import {
-  view
-} from "./chunk-RCQMWXEW.mjs";
-import {
-  getBlockByHeight,
-  getBlockByVersion,
-  getChainTopUserTransactions,
-  getIndexerLastSuccessVersion,
-  getLedgerInfo,
-  getProcessorStatus,
-  getTableItem,
-  queryIndexer
-} from "./chunk-LYMY63SO.mjs";
-
-// src/api/general.ts
-var General = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Queries for the Aptos ledger info
-   *
-   * @returns Aptos Ledger Info
-   *
-   * @example
-   * const ledgerInfo = await aptos.getLedgerInfo()
-   * // an example of the returned data
-   * ```
-   * {
-   * "chain_id": 4,
-   * "epoch": "8",
-   * "ledger_version": "714",
-   * "oldest_ledger_version": "0",
-   * "ledger_timestamp": "1694695496521775",
-   * "node_role": "validator",
-   * "oldest_block_height": "0",
-   * "block_height": "359",
-   * "git_hash": "c82193f36f4e185fed9f68c4ad21f6c6dd390c6e"
-   * }
-   * ```
-   */
-  async getLedgerInfo() {
-    return getLedgerInfo({ aptosConfig: this.config });
-  }
-  /**
-   * Queries for the chain id
-   *
-   * @example
-   * const chainId = await aptos.getChainId()
-   *
-   * @returns The chain id
-   */
-  async getChainId() {
-    const result = await this.getLedgerInfo();
-    return result.chain_id;
-  }
-  /**
-   * Queries for block by transaction version
-   *
-   * @example
-   * const block = await aptos.getBlockByVersion({ledgerVersion:5})
-   *
-   * @param args.ledgerVersion Ledger version to lookup block information for
-   * @param args.options.withTransactions If set to true, include all transactions in the block
-   *
-   * @returns Block information with optional transactions
-   */
-  async getBlockByVersion(args) {
-    return getBlockByVersion({
-      aptosConfig: this.config,
-      ...args
-    });
-  }
-  /**
-   * Get block by block height
-   *
-   * @example
-   * const block = await aptos.getBlockByVersion({blockHeight:5})
-   *
-   * @param args.blockHeight Block height to lookup.  Starts at 0
-   * @param args.options.withTransactions If set to true, include all transactions in the block
-   *
-   * @returns Block with optional transactions
-   */
-  async getBlockByHeight(args) {
-    return getBlockByHeight({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries for a table item for a table identified by the handle and the key for the item.
-   * Key and value types need to be passed in to help with key serialization and value deserialization.
-   *
-   * @example https://api.devnet.aptoslabs.com/v1/accounts/0x1/resource/0x1::coin::CoinInfo%3C0x1::aptos_coin::AptosCoin%3E
-   * const tableItem = await aptos.getTableItem({
-   *  handle: "0x123",
-   *  data: {
-   *   key_type: "address", // Move type of table key
-   *   value_type: "u128", // Move type of table value
-   *   key: "0x619dc29a0aac8fa146714058e8dd6d2d0f3bdf5f6331907bf91f3acd81e6935" // Value of table key
-   *  },
-   * })
-   *
-   * @param args.handle A pointer to where that table is stored
-   * @param args.data Object that describes table item
-   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-   *
-   * @returns Table item value rendered in JSON
-   */
-  async getTableItem(args) {
-    return getTableItem({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries for a Move view function
-   * @param args.payload Payload for the view function
-   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-   *
-   * @example
-   * const data = await aptos.view({
-   *  payload: {
-   *   function: "0x1::coin::balance",
-   *   typeArguments: ["0x1::aptos_coin::AptosCoin"],
-   *   functionArguments: [accountAddress],
-   *  }
-   * })
-   *
-   * @returns an array of Move values
-   */
-  async view(args) {
-    return view({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries top user transactions
-   *
-   * @example
-   * const topUserTransactions = await aptos.getChainTopUserTransactions({limit:5})
-   *
-   * @param args.limit The number of transactions to return
-   * @returns GetChainTopUserTransactionsResponse
-   */
-  async getChainTopUserTransactions(args) {
-    return getChainTopUserTransactions({
-      aptosConfig: this.config,
-      ...args
-    });
-  }
-  /**
-   * A generic function for retrieving data from Aptos Indexer.
-   * For more detailed queries specification see
-   * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://api.mainnet.aptoslabs.com/v1/graphql}
-   *
-   * @example
-   * const topUserTransactions = await aptos.queryIndexer({
-   *  query: `query MyQuery {
-   *   ledger_infos {
-   *     chain_id
-   *   }}`;
-   * })
-   *
-   * @param args.query.query A GraphQL query
-   * @param args.query.variables The variables for the query
-   *
-   * @return The provided T type
-   */
-  async queryIndexer(args) {
-    return queryIndexer({
-      aptosConfig: this.config,
-      ...args
-    });
-  }
-  /**
-   * Queries for the last successful indexer version
-   *
-   * This is useful to tell what ledger version the indexer is updated to, as it can be behind the full nodes.
-   *
-   * @example
-   * const version = await aptos.getIndexerLastSuccessVersion()
-   */
-  async getIndexerLastSuccessVersion() {
-    return getIndexerLastSuccessVersion({ aptosConfig: this.config });
-  }
-  /**
-   * Query the processor status for a specific processor type.
-   *
-   * @example
-   * const status = await aptos.getProcessorStatus({processorType:"account_transactions_processor"})
-   *
-   * @param processorType The processor type to query
-   * @returns
-   */
-  async getProcessorStatus(processorType) {
-    return getProcessorStatus({ aptosConfig: this.config, processorType });
-  }
-};
-
-export {
-  General
-};
-//# sourceMappingURL=chunk-VZQXLVEP.mjs.map

package/dist/esm/chunk-W76MGKZB.mjs

@@ -1,33 +0,0 @@
-import {
-  ValidateFeePayerDataOnSimulation
-} from "./chunk-SIJELMDP.mjs";
-import {
-  simulateTransaction
-} from "./chunk-IHNPN5CQ.mjs";
-import {
-  __decorateClass
-} from "./chunk-OR7TEZ25.mjs";
-
-// src/api/transactionSubmission/simulate.ts
-var Simulate = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async simple(args) {
-    return simulateTransaction({ aptosConfig: this.config, ...args });
-  }
-  async multiAgent(args) {
-    return simulateTransaction({ aptosConfig: this.config, ...args });
-  }
-};
-__decorateClass([
-  ValidateFeePayerDataOnSimulation
-], Simulate.prototype, "simple", 1);
-__decorateClass([
-  ValidateFeePayerDataOnSimulation
-], Simulate.prototype, "multiAgent", 1);
-
-export {
-  Simulate
-};
-//# sourceMappingURL=chunk-W76MGKZB.mjs.map

package/dist/esm/chunk-WDRH2URB.mjs

@@ -1,91 +0,0 @@
-import {
-  TransactionWorker
-} from "./chunk-WVGO4D7K.mjs";
-
-// src/api/transactionSubmission/management.ts
-import EventEmitter from "eventemitter3";
-var TransactionManagement = class extends EventEmitter {
-  constructor(config) {
-    super();
-    this.config = config;
-  }
-  /**
-   * Internal function to start the transaction worker and
-   * listen to worker events
-   *
-   * @param args.sender The sender account to sign and submit the transaction
-   */
-  start(args) {
-    const { sender } = args;
-    this.account = sender;
-    this.transactionWorker = new TransactionWorker(this.config, sender);
-    this.transactionWorker.start();
-    this.registerToEvents();
-  }
-  /**
-   * Internal function to push transaction data to the transaction worker.
-   *
-   * @param args.data An array of transaction payloads
-   * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)
-   *
-   * TODO - make this public once worker supports adding transactions to existing queue
-   */
-  push(args) {
-    const { data, options } = args;
-    for (const d of data) {
-      this.transactionWorker.push(d, options);
-    }
-  }
-  /**
-   * Internal function to start listening to transaction worker events
-   *
-   * TODO - should we ask events to listen to as an input?
-   */
-  registerToEvents() {
-    this.transactionWorker.on("transactionSent" /* TransactionSent */, async (data) => {
-      this.emit("transactionSent" /* TransactionSent */, data);
-    });
-    this.transactionWorker.on("transactionSendFailed" /* TransactionSendFailed */, async (data) => {
-      this.emit("transactionSendFailed" /* TransactionSendFailed */, data);
-    });
-    this.transactionWorker.on("transactionExecuted" /* TransactionExecuted */, async (data) => {
-      this.emit("transactionExecuted" /* TransactionExecuted */, data);
-    });
-    this.transactionWorker.on("transactionExecutionFailed" /* TransactionExecutionFailed */, async (data) => {
-      this.emit("transactionExecutionFailed" /* TransactionExecutionFailed */, data);
-    });
-    this.transactionWorker.on("executionFinish" /* ExecutionFinish */, async (data) => {
-      this.emit("executionFinish" /* ExecutionFinish */, data);
-    });
-  }
-  /**
-   * Send batch transactions for a single account.
-   *
-   * This function uses a transaction worker that receives payloads to be processed
-   * and submitted to chain.
-   * Note that this process is best for submitting multiple transactions that
-   * dont rely on each other, i.e batch funds, batch token mints, etc.
-   *
-   * If any worker failure, the functions throws an error.
-   *
-   * @param args.sender The sender account to sign and submit the transaction
-   * @param args.data An array of transaction payloads
-   * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)
-   *
-   * @return void. Throws if any error
-   */
-  forSingleAccount(args) {
-    try {
-      const { sender, data, options } = args;
-      this.start({ sender });
-      this.push({ data, options });
-    } catch (error) {
-      throw new Error(`failed to submit transactions with error: ${error}`);
-    }
-  }
-};
-
-export {
-  TransactionManagement
-};
-//# sourceMappingURL=chunk-WDRH2URB.mjs.map

package/dist/esm/chunk-WHBWEN6N.mjs

@@ -1,206 +0,0 @@
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-TLNHRJB2.mjs";
-import {
-  Signature
-} from "./chunk-FDWJNY4U.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-FXKSE3ZP.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-UEBBLQJ5.mjs";
-
-// src/core/crypto/multiKey.ts
-function bitCount(byte) {
-  let n = byte;
-  n -= n >> 1 & 1431655765;
-  n = (n & 858993459) + (n >> 2 & 858993459);
-  return (n + (n >> 4) & 252645135) * 16843009 >> 24;
-}
-var MultiKey = class _MultiKey extends AccountPublicKey {
-  // region Constructors
-  constructor(args) {
-    super();
-    const { publicKeys, signaturesRequired } = args;
-    if (signaturesRequired < 1) {
-      throw new Error("The number of required signatures needs to be greater than 0");
-    }
-    if (publicKeys.length < signaturesRequired) {
-      throw new Error(
-        `Provided ${publicKeys.length} public keys is smaller than the ${signaturesRequired} required signatures`
-      );
-    }
-    this.publicKeys = publicKeys.map(
-      (publicKey) => publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey)
-    );
-    this.signaturesRequired = signaturesRequired;
-  }
-  // endregion
-  // region AccountPublicKey
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args) {
-    throw new Error("not implemented");
-  }
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 3 /* MultiKey */,
-      input: this.toUint8Array()
-    });
-  }
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeVector(this.publicKeys);
-    serializer.serializeU8(this.signaturesRequired);
-  }
-  static deserialize(deserializer) {
-    const keys = deserializer.deserializeVector(AnyPublicKey);
-    const signaturesRequired = deserializer.deserializeU8();
-    return new _MultiKey({ publicKeys: keys, signaturesRequired });
-  }
-  // endregion
-  /**
-   * Create a bitmap that holds the mapping from the original public keys
-   * to the signatures passed in
-   *
-   * @param args.bits array of the index mapping to the matching public keys
-   * @returns Uint8array bit map
-   */
-  createBitmap(args) {
-    const { bits } = args;
-    const firstBitInByte = 128;
-    const bitmap = new Uint8Array([0, 0, 0, 0]);
-    const dupCheckSet = /* @__PURE__ */ new Set();
-    bits.forEach((bit, idx) => {
-      if (idx + 1 > this.publicKeys.length) {
-        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);
-      }
-      if (dupCheckSet.has(bit)) {
-        throw new Error(`Duplicate bit ${bit} detected.`);
-      }
-      dupCheckSet.add(bit);
-      const byteOffset = Math.floor(bit / 8);
-      let byte = bitmap[byteOffset];
-      byte |= firstBitInByte >> bit % 8;
-      bitmap[byteOffset] = byte;
-    });
-    return bitmap;
-  }
-  /**
-   * Get the index of the provided public key.
-   *
-   * @param publicKey array of the index mapping to the matching public keys
-   * @returns the corresponding index of the publicKey, if it exists
-   */
-  getIndex(publicKey) {
-    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
-    const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());
-    if (index !== -1) {
-      return index;
-    }
-    throw new Error("Public key not found in MultiKey");
-  }
-};
-var _MultiKeySignature = class _MultiKeySignature 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
-   */
-  constructor(args) {
-    super();
-    const { signatures, bitmap } = args;
-    if (signatures.length > _MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
-      throw new Error(`The number of signatures cannot be greater than ${_MultiKeySignature.MAX_SIGNATURES_SUPPORTED}`);
-    }
-    this.signatures = signatures.map(
-      (signature) => signature instanceof AnySignature ? signature : new AnySignature(signature)
-    );
-    if (!(bitmap instanceof Uint8Array)) {
-      this.bitmap = _MultiKeySignature.createBitmap({ bits: bitmap });
-    } else if (bitmap.length !== _MultiKeySignature.BITMAP_LEN) {
-      throw new Error(`"bitmap" length should be ${_MultiKeySignature.BITMAP_LEN}`);
-    } else {
-      this.bitmap = bitmap;
-    }
-    const nSignatures = this.bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);
-    if (nSignatures !== this.signatures.length) {
-      throw new Error(`Expecting ${nSignatures} signatures from the bitmap, but got ${this.signatures.length}`);
-    }
-  }
-  /**
-   * 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) => {
-      if (bit >= _MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
-        throw new Error(`Cannot have a signature larger than ${_MultiKeySignature.MAX_SIGNATURES_SUPPORTED - 1}.`);
-      }
-      if (dupCheckSet.has(bit)) {
-        throw new Error("Duplicate bits detected.");
-      }
-      dupCheckSet.add(bit);
-      const byteOffset = Math.floor(bit / 8);
-      let byte = bitmap[byteOffset];
-      byte |= firstBitInByte >> bit % 8;
-      bitmap[byteOffset] = byte;
-    });
-    return bitmap;
-  }
-  // region Signature
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeVector(this.signatures);
-    serializer.serializeBytes(this.bitmap);
-  }
-  static deserialize(deserializer) {
-    const signatures = deserializer.deserializeVector(AnySignature);
-    const bitmap = deserializer.deserializeBytes();
-    return new _MultiKeySignature({ signatures, bitmap });
-  }
-  // endregion
-};
-/**
- * Number of bytes in the bitmap representing who signed the transaction (32-bits)
- */
-_MultiKeySignature.BITMAP_LEN = 4;
-/**
- * Maximum number of Ed25519 signatures supported
- */
-_MultiKeySignature.MAX_SIGNATURES_SUPPORTED = _MultiKeySignature.BITMAP_LEN * 8;
-var MultiKeySignature = _MultiKeySignature;
-
-export {
-  MultiKey,
-  MultiKeySignature
-};
-//# sourceMappingURL=chunk-WHBWEN6N.mjs.map

package/dist/esm/chunk-WK5ZSNE2.mjs

@@ -1,173 +0,0 @@
-import {
-  Serializable,
-  ensureBoolean,
-  validateNumberInRange
-} from "./chunk-FQQW55X7.mjs";
-import {
-  MAX_U128_BIG_INT,
-  MAX_U16_NUMBER,
-  MAX_U256_BIG_INT,
-  MAX_U32_NUMBER,
-  MAX_U64_BIG_INT,
-  MAX_U8_NUMBER
-} from "./chunk-SBB4YEPT.mjs";
-
-// src/bcs/serializable/movePrimitives.ts
-var Bool = class _Bool extends Serializable {
-  constructor(value) {
-    super();
-    ensureBoolean(value);
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeBool(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(5 /* Bool */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _Bool(deserializer.deserializeBool());
-  }
-};
-var U8 = class _U8 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, 0, MAX_U8_NUMBER);
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeU8(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(0 /* U8 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U8(deserializer.deserializeU8());
-  }
-};
-var U16 = class _U16 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, 0, MAX_U16_NUMBER);
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeU16(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(6 /* U16 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U16(deserializer.deserializeU16());
-  }
-};
-var U32 = class _U32 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, 0, MAX_U32_NUMBER);
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeU32(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(7 /* U32 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U32(deserializer.deserializeU32());
-  }
-};
-var U64 = class _U64 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, BigInt(0), MAX_U64_BIG_INT);
-    this.value = BigInt(value);
-  }
-  serialize(serializer) {
-    serializer.serializeU64(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(1 /* U64 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U64(deserializer.deserializeU64());
-  }
-};
-var U128 = class _U128 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, BigInt(0), MAX_U128_BIG_INT);
-    this.value = BigInt(value);
-  }
-  serialize(serializer) {
-    serializer.serializeU128(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(2 /* U128 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U128(deserializer.deserializeU128());
-  }
-};
-var U256 = class _U256 extends Serializable {
-  constructor(value) {
-    super();
-    validateNumberInRange(value, BigInt(0), MAX_U256_BIG_INT);
-    this.value = BigInt(value);
-  }
-  serialize(serializer) {
-    serializer.serializeU256(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serializeU32AsUleb128(8 /* U256 */);
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer) {
-    return new _U256(deserializer.deserializeU256());
-  }
-};
-
-export {
-  Bool,
-  U8,
-  U16,
-  U32,
-  U64,
-  U128,
-  U256
-};
-//# sourceMappingURL=chunk-WK5ZSNE2.mjs.map