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

package/dist/esm/chunk-HBNSRCZN.mjs

@@ -1,100 +0,0 @@
-import {
-  getAccountEventsByCreationNumber,
-  getAccountEventsByEventType,
-  getEvents,
-  getModuleEventsByEventType
-} from "./chunk-CTJSZT5V.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-CC4DQ6NH.mjs";
-
-// src/api/event.ts
-var Event = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Get module events by event type
-   *
-   * @example
-   * const events = await aptos.getModuleEventsByEventType({eventType:"0x1::transaction_fee::FeeStatement"})
-   *
-   * @param args.eventType - The event type
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   *
-   * @returns Promise<GetEventsResponse>
-   */
-  async getModuleEventsByEventType(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "events_processor" /* EVENTS_PROCESSOR */
-    });
-    return getModuleEventsByEventType({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Get events by creation number and an account address
-   *
-   * @example
-   * const events = await aptos.getAccountEventsByCreationNumber({accountAddress:"0x123",creationNumber: 0})
-   *
-   * @param args.accountAddress - The account address
-   * @param args.creationNumber - The event creation number
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   *
-   * @returns Promise<GetEventsResponse>
-   */
-  async getAccountEventsByCreationNumber(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "events_processor" /* EVENTS_PROCESSOR */
-    });
-    return getAccountEventsByCreationNumber({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Get events by event type and an account address
-   *
-   * @example
-   * const events = await aptos.getAccountEventsByEventType({accountAddress:"0x123",eventType: "0x1::transaction_fee::FeeStatement"})
-   *
-   * @param args.accountAddress - The account address
-   * @param args.eventType - The event type
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   *
-   * @returns Promise<GetEventsResponse>
-   */
-  async getAccountEventsByEventType(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "events_processor" /* EVENTS_PROCESSOR */
-    });
-    return getAccountEventsByEventType({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Get all events
-   *
-   * An optional `where` can be passed in to filter out the response.
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @example
-   * const events = await aptos.getEvents()
-   * // with filtering
-   * const events = await aptos.getEvents({options: { where: { account_address: { _eq: "0x123" } } }});
-   *
-   * @returns GetEventsQuery response type
-   */
-  async getEvents(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "events_processor" /* EVENTS_PROCESSOR */
-    });
-    return getEvents({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  Event
-};
-//# sourceMappingURL=chunk-HBNSRCZN.mjs.map

package/dist/esm/chunk-IC56GQFJ.mjs

@@ -1,127 +0,0 @@
-import {
-  MultiEd25519PublicKey,
-  MultiEd25519Signature
-} from "./chunk-UKU6A2W2.mjs";
-import {
-  MultiKey,
-  MultiKeySignature
-} from "./chunk-WHBWEN6N.mjs";
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-TLNHRJB2.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-
-// src/transactions/authenticator/account.ts
-var AccountAuthenticator = class extends Serializable {
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Ed25519 */:
-        return AccountAuthenticatorEd25519.load(deserializer);
-      case 1 /* MultiEd25519 */:
-        return AccountAuthenticatorMultiEd25519.load(deserializer);
-      case 2 /* SingleKey */:
-        return AccountAuthenticatorSingleKey.load(deserializer);
-      case 3 /* MultiKey */:
-        return AccountAuthenticatorMultiKey.load(deserializer);
-      default:
-        throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
-    }
-  }
-  isEd25519() {
-    return this instanceof AccountAuthenticatorEd25519;
-  }
-  isMultiEd25519() {
-    return this instanceof AccountAuthenticatorMultiEd25519;
-  }
-  isSingleKey() {
-    return this instanceof AccountAuthenticatorSingleKey;
-  }
-  isMultiKey() {
-    return this instanceof AccountAuthenticatorMultiKey;
-  }
-};
-var AccountAuthenticatorEd25519 = class _AccountAuthenticatorEd25519 extends AccountAuthenticator {
-  constructor(public_key, signature) {
-    super();
-    this.public_key = public_key;
-    this.signature = signature;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* Ed25519 */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_key = Ed25519PublicKey.deserialize(deserializer);
-    const signature = Ed25519Signature.deserialize(deserializer);
-    return new _AccountAuthenticatorEd25519(public_key, signature);
-  }
-};
-var AccountAuthenticatorMultiEd25519 = class _AccountAuthenticatorMultiEd25519 extends AccountAuthenticator {
-  constructor(public_key, signature) {
-    super();
-    this.public_key = public_key;
-    this.signature = signature;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(1 /* MultiEd25519 */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_key = MultiEd25519PublicKey.deserialize(deserializer);
-    const signature = MultiEd25519Signature.deserialize(deserializer);
-    return new _AccountAuthenticatorMultiEd25519(public_key, signature);
-  }
-};
-var AccountAuthenticatorSingleKey = class _AccountAuthenticatorSingleKey extends AccountAuthenticator {
-  constructor(public_key, signature) {
-    super();
-    this.public_key = public_key;
-    this.signature = signature;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(2 /* SingleKey */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_key = AnyPublicKey.deserialize(deserializer);
-    const signature = AnySignature.deserialize(deserializer);
-    return new _AccountAuthenticatorSingleKey(public_key, signature);
-  }
-};
-var AccountAuthenticatorMultiKey = class _AccountAuthenticatorMultiKey extends AccountAuthenticator {
-  constructor(public_keys, signatures) {
-    super();
-    this.public_keys = public_keys;
-    this.signatures = signatures;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(3 /* MultiKey */);
-    this.public_keys.serialize(serializer);
-    this.signatures.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_keys = MultiKey.deserialize(deserializer);
-    const signatures = MultiKeySignature.deserialize(deserializer);
-    return new _AccountAuthenticatorMultiKey(public_keys, signatures);
-  }
-};
-
-export {
-  AccountAuthenticator,
-  AccountAuthenticatorEd25519,
-  AccountAuthenticatorMultiEd25519,
-  AccountAuthenticatorSingleKey,
-  AccountAuthenticatorMultiKey
-};
-//# sourceMappingURL=chunk-IC56GQFJ.mjs.map

package/dist/esm/chunk-IHNPN5CQ.mjs

@@ -1,256 +0,0 @@
-import {
-  KeylessError
-} from "./chunk-2JOCR2VL.mjs";
-import {
-  buildTransaction,
-  generateSignedTransaction,
-  generateSignedTransactionForSimulation,
-  generateTransactionPayload
-} from "./chunk-U7QBZ6PP.mjs";
-import {
-  getInfo
-} from "./chunk-Y2LV3S5W.mjs";
-import {
-  postAptosFullNode
-} from "./chunk-NXFO2W4G.mjs";
-import {
-  AptosApiError
-} from "./chunk-PCLNX6FS.mjs";
-import {
-  Account
-} from "./chunk-VDJBDX3A.mjs";
-import {
-  MultiKeyAccount
-} from "./chunk-6LRQSBRH.mjs";
-import {
-  KeylessAccount
-} from "./chunk-JV3GSIJW.mjs";
-import {
-  generateSigningMessageForTransaction
-} from "./chunk-VJP2VWMF.mjs";
-import {
-  RotationProofChallenge
-} from "./chunk-XANFAUBD.mjs";
-import {
-  TypeTagU8,
-  TypeTagVector
-} from "./chunk-7FO3S6IZ.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  MoveVector
-} from "./chunk-AR7X6GWQ.mjs";
-import {
-  U8
-} from "./chunk-WK5ZSNE2.mjs";
-
-// src/internal/transactionSubmission.ts
-async function generateTransaction(args) {
-  const payload = await buildTransactionPayload(args);
-  return buildRawTransaction(args, payload);
-}
-async function buildTransactionPayload(args) {
-  const { aptosConfig, data } = args;
-  let generateTransactionPayloadData;
-  let payload;
-  if ("bytecode" in data) {
-    payload = await generateTransactionPayload(data);
-  } else if ("multisigAddress" in data) {
-    generateTransactionPayloadData = {
-      aptosConfig,
-      multisigAddress: data.multisigAddress,
-      function: data.function,
-      functionArguments: data.functionArguments,
-      typeArguments: data.typeArguments,
-      abi: data.abi
-    };
-    payload = await generateTransactionPayload(generateTransactionPayloadData);
-  } else {
-    generateTransactionPayloadData = {
-      aptosConfig,
-      function: data.function,
-      functionArguments: data.functionArguments,
-      typeArguments: data.typeArguments,
-      abi: data.abi
-    };
-    payload = await generateTransactionPayload(generateTransactionPayloadData);
-  }
-  return payload;
-}
-async function buildRawTransaction(args, payload) {
-  const { aptosConfig, sender, options } = args;
-  let feePayerAddress;
-  if (isFeePayerTransactionInput(args)) {
-    feePayerAddress = AccountAddress.ZERO.toString();
-  }
-  if (isMultiAgentTransactionInput(args)) {
-    const { secondarySignerAddresses } = args;
-    return buildTransaction({
-      aptosConfig,
-      sender,
-      payload,
-      options,
-      secondarySignerAddresses,
-      feePayerAddress
-    });
-  }
-  return buildTransaction({
-    aptosConfig,
-    sender,
-    payload,
-    options,
-    feePayerAddress
-  });
-}
-function isFeePayerTransactionInput(data) {
-  return data.withFeePayer === true;
-}
-function isMultiAgentTransactionInput(data) {
-  return "secondarySignerAddresses" in data;
-}
-function getSigningMessage(args) {
-  const { transaction } = args;
-  return generateSigningMessageForTransaction(transaction);
-}
-function signTransaction(args) {
-  const { signer, transaction } = args;
-  return signer.signTransactionWithAuthenticator(transaction);
-}
-async function simulateTransaction(args) {
-  const { aptosConfig, transaction, signerPublicKey, secondarySignersPublicKeys, feePayerPublicKey, options } = args;
-  const signedTransaction = generateSignedTransactionForSimulation({
-    transaction,
-    signerPublicKey,
-    secondarySignersPublicKeys,
-    feePayerPublicKey,
-    options
-  });
-  const { data } = await postAptosFullNode({
-    aptosConfig,
-    body: signedTransaction,
-    path: "transactions/simulate",
-    params: {
-      estimate_gas_unit_price: args.options?.estimateGasUnitPrice ?? false,
-      estimate_max_gas_amount: args.options?.estimateMaxGasAmount ?? false,
-      estimate_prioritized_gas_unit_price: args.options?.estimatePrioritizedGasUnitPrice ?? false
-    },
-    originMethod: "simulateTransaction",
-    contentType: "application/x.aptos.signed_transaction+bcs" /* BCS_SIGNED_TRANSACTION */
-  });
-  return data;
-}
-async function submitTransaction(args) {
-  const { aptosConfig } = args;
-  const signedTransaction = generateSignedTransaction({ ...args });
-  const { data } = await postAptosFullNode({
-    aptosConfig,
-    body: signedTransaction,
-    path: "transactions",
-    originMethod: "submitTransaction",
-    contentType: "application/x.aptos.signed_transaction+bcs" /* BCS_SIGNED_TRANSACTION */
-  });
-  return data;
-}
-async function signAndSubmitTransaction(args) {
-  const { aptosConfig, signer, transaction } = args;
-  if (signer instanceof KeylessAccount || signer instanceof MultiKeyAccount) {
-    await signer.waitForProofFetch();
-  }
-  const authenticator = signTransaction({ signer, transaction });
-  try {
-    return await submitTransaction({
-      aptosConfig,
-      transaction,
-      senderAuthenticator: authenticator
-    });
-  } catch (error) {
-    if (error instanceof AptosApiError && signer instanceof KeylessAccount) {
-      throw await KeylessError.fromAptosApiError(error, signer);
-    }
-    throw error;
-  }
-}
-var packagePublishAbi = {
-  typeParameters: [],
-  parameters: [TypeTagVector.u8(), new TypeTagVector(TypeTagVector.u8())]
-};
-async function publicPackageTransaction(args) {
-  const { aptosConfig, account, metadataBytes, moduleBytecode, options } = args;
-  const totalByteCode = moduleBytecode.map((bytecode) => MoveVector.U8(bytecode));
-  return generateTransaction({
-    aptosConfig,
-    sender: AccountAddress.from(account),
-    data: {
-      function: "0x1::code::publish_package_txn",
-      functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)],
-      abi: packagePublishAbi
-    },
-    options
-  });
-}
-var rotateAuthKeyAbi = {
-  typeParameters: [],
-  parameters: [
-    new TypeTagU8(),
-    TypeTagVector.u8(),
-    new TypeTagU8(),
-    TypeTagVector.u8(),
-    TypeTagVector.u8(),
-    TypeTagVector.u8()
-  ]
-};
-async function rotateAuthKey(args) {
-  const { aptosConfig, fromAccount, toNewPrivateKey } = args;
-  const accountInfo = await getInfo({
-    aptosConfig,
-    accountAddress: fromAccount.accountAddress
-  });
-  const newAccount = Account.fromPrivateKey({ privateKey: toNewPrivateKey, legacy: true });
-  const challenge = new RotationProofChallenge({
-    sequenceNumber: BigInt(accountInfo.sequence_number),
-    originator: fromAccount.accountAddress,
-    currentAuthKey: AccountAddress.from(accountInfo.authentication_key),
-    newPublicKey: newAccount.publicKey
-  });
-  const challengeHex = challenge.bcsToBytes();
-  const proofSignedByCurrentPrivateKey = fromAccount.sign(challengeHex);
-  const proofSignedByNewPrivateKey = newAccount.sign(challengeHex);
-  const rawTxn = await generateTransaction({
-    aptosConfig,
-    sender: fromAccount.accountAddress,
-    data: {
-      function: "0x1::account::rotate_authentication_key",
-      functionArguments: [
-        new U8(fromAccount.signingScheme),
-        // from scheme
-        MoveVector.U8(fromAccount.publicKey.toUint8Array()),
-        new U8(newAccount.signingScheme),
-        // to scheme
-        MoveVector.U8(newAccount.publicKey.toUint8Array()),
-        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),
-        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array())
-      ],
-      abi: rotateAuthKeyAbi
-    }
-  });
-  return signAndSubmitTransaction({
-    aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn
-  });
-}
-
-export {
-  generateTransaction,
-  buildTransactionPayload,
-  buildRawTransaction,
-  getSigningMessage,
-  signTransaction,
-  simulateTransaction,
-  submitTransaction,
-  signAndSubmitTransaction,
-  publicPackageTransaction,
-  rotateAuthKey
-};
-//# sourceMappingURL=chunk-IHNPN5CQ.mjs.map

package/dist/esm/chunk-JHDHNGJ3.mjs

@@ -1,126 +0,0 @@
-import {
-  generateSigningMessageForTransaction
-} from "./chunk-VJP2VWMF.mjs";
-import {
-  AccountAuthenticatorSingleKey
-} from "./chunk-IC56GQFJ.mjs";
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-TLNHRJB2.mjs";
-import {
-  Secp256k1PrivateKey
-} from "./chunk-DIYZRGR6.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.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-JHDHNGJ3.mjs.map

package/dist/esm/chunk-JL2JHVS4.mjs

@@ -1,49 +0,0 @@
-import {
-  Identifier
-} from "./chunk-2TJJWII2.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-
-// src/transactions/instances/moduleId.ts
-var ModuleId = class _ModuleId extends Serializable {
-  /**
-   * Full name of a module.
-   * @param address The account address. e.g "0x1"
-   * @param name The module name under the "address". e.g "coin"
-   */
-  constructor(address, name) {
-    super();
-    this.address = address;
-    this.name = name;
-  }
-  /**
-   * Converts a string literal to a ModuleId
-   * @param moduleId String literal in format "account_address::module_name", e.g. "0x1::coin"
-   * @returns ModuleId
-   */
-  static fromStr(moduleId) {
-    const parts = moduleId.split("::");
-    if (parts.length !== 2) {
-      throw new Error("Invalid module id.");
-    }
-    return new _ModuleId(AccountAddress.fromString(parts[0]), new Identifier(parts[1]));
-  }
-  serialize(serializer) {
-    this.address.serialize(serializer);
-    this.name.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const address = AccountAddress.deserialize(deserializer);
-    const name = Identifier.deserialize(deserializer);
-    return new _ModuleId(address, name);
-  }
-};
-
-export {
-  ModuleId
-};
-//# sourceMappingURL=chunk-JL2JHVS4.mjs.map