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

package/dist/esm/chunk-DXGNWBVW.mjs

@@ -1,127 +0,0 @@
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  MoveOption,
-  MoveString,
-  MoveVector
-} from "./chunk-PSW5OBY2.mjs";
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-GWS7OLIU.mjs";
-import {
-  FixedBytes
-} from "./chunk-ACAXM6CI.mjs";
-
-// src/transactions/transactionBuilder/helpers.ts
-function isBool(arg) {
-  return typeof arg === "boolean";
-}
-function isString(arg) {
-  return typeof arg === "string";
-}
-function isNumber(arg) {
-  return typeof arg === "number";
-}
-function convertNumber(arg) {
-  if (isNumber(arg)) {
-    return arg;
-  }
-  if (isString(arg) && arg !== "") {
-    return Number.parseInt(arg, 10);
-  }
-  return void 0;
-}
-function isLargeNumber(arg) {
-  return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
-}
-function isEmptyOption(arg) {
-  return arg === null || arg === void 0;
-}
-function isEncodedEntryFunctionArgument(arg) {
-  return isBcsBool(arg) || isBcsU8(arg) || isBcsU16(arg) || isBcsU32(arg) || isBcsU64(arg) || isBcsU128(arg) || isBcsU256(arg) || isBcsAddress(arg) || isBcsString(arg) || isBcsFixedBytes(arg) || arg instanceof MoveVector || arg instanceof MoveOption;
-}
-function isBcsBool(arg) {
-  return arg instanceof Bool;
-}
-function isBcsAddress(arg) {
-  return arg instanceof AccountAddress;
-}
-function isBcsString(arg) {
-  return arg instanceof MoveString;
-}
-function isBcsFixedBytes(arg) {
-  return arg instanceof FixedBytes;
-}
-function isBcsU8(arg) {
-  return arg instanceof U8;
-}
-function isBcsU16(arg) {
-  return arg instanceof U16;
-}
-function isBcsU32(arg) {
-  return arg instanceof U32;
-}
-function isBcsU64(arg) {
-  return arg instanceof U64;
-}
-function isBcsU128(arg) {
-  return arg instanceof U128;
-}
-function isBcsU256(arg) {
-  return arg instanceof U256;
-}
-function isScriptDataInput(arg) {
-  return "bytecode" in arg;
-}
-function throwTypeMismatch(expectedType, position) {
-  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
-}
-function findFirstNonSignerArg(functionAbi) {
-  const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
-  if (index < 0) {
-    return functionAbi.params.length;
-  }
-  return index;
-}
-function getFunctionParts(functionArg) {
-  const funcNameParts = functionArg.split("::");
-  if (funcNameParts.length !== 3) {
-    throw new Error(`Invalid function ${functionArg}`);
-  }
-  const moduleAddress = funcNameParts[0];
-  const moduleName = funcNameParts[1];
-  const functionName = funcNameParts[2];
-  return { moduleAddress, moduleName, functionName };
-}
-
-export {
-  isBool,
-  isString,
-  isNumber,
-  convertNumber,
-  isLargeNumber,
-  isEmptyOption,
-  isEncodedEntryFunctionArgument,
-  isBcsBool,
-  isBcsAddress,
-  isBcsString,
-  isBcsFixedBytes,
-  isBcsU8,
-  isBcsU16,
-  isBcsU32,
-  isBcsU64,
-  isBcsU128,
-  isBcsU256,
-  isScriptDataInput,
-  throwTypeMismatch,
-  findFirstNonSignerArg,
-  getFunctionParts
-};
-//# sourceMappingURL=chunk-DXGNWBVW.mjs.map

package/dist/esm/chunk-EKY7QRXH.mjs

@@ -1,79 +0,0 @@
-import {
-  SingleKeyAccount
-} from "./chunk-GDE3IBAB.mjs";
-import {
-  Ed25519Account
-} from "./chunk-ZR36Y2RX.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-B673XLJY.mjs";
-
-// src/account/Account.ts
-var Account = class {
-  static generate(args = {}) {
-    const { scheme = 0 /* Ed25519 */, legacy = true } = args;
-    if (scheme === 0 /* Ed25519 */ && legacy) {
-      return Ed25519Account.generate();
-    }
-    return SingleKeyAccount.generate({ scheme });
-  }
-  static fromPrivateKey(args) {
-    const { privateKey, address, legacy = true } = args;
-    if (privateKey instanceof Ed25519PrivateKey && legacy) {
-      return new Ed25519Account({
-        privateKey,
-        address
-      });
-    }
-    return new SingleKeyAccount({ privateKey, address });
-  }
-  /**
-   * @deprecated use `fromPrivateKey` instead.
-   * Instantiates an account given a private key and a specified account address.
-   * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
-   *
-   * @param args.privateKey PrivateKey - the underlying private key for the account
-   * @param args.address AccountAddress - The account address the `Account` will sign for
-   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-   * to generating a Legacy Ed25519 keypair
-   *
-   * @returns Account
-   */
-  static fromPrivateKeyAndAddress(args) {
-    return this.fromPrivateKey(args);
-  }
-  static fromDerivationPath(args) {
-    const { scheme = 0 /* Ed25519 */, mnemonic, path, legacy = true } = args;
-    if (scheme === 0 /* Ed25519 */ && legacy) {
-      return Ed25519Account.fromDerivationPath({ mnemonic, path });
-    }
-    return SingleKeyAccount.fromDerivationPath({ scheme, mnemonic, path });
-  }
-  /**
-   * @deprecated use `publicKey.authKey()` instead.
-   * This key enables account owners to rotate their private key(s)
-   * associated with the account without changing the address that hosts their account.
-   * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
-   *
-   * @param args.publicKey PublicKey - public key of the account
-   * @returns The authentication key for the associated account
-   */
-  static authKey(args) {
-    const { publicKey } = args;
-    return publicKey.authKey();
-  }
-  /**
-   * 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);
-  }
-};
-
-export {
-  Account
-};
-//# sourceMappingURL=chunk-EKY7QRXH.mjs.map

package/dist/esm/chunk-EPUYKFAT.mjs

@@ -1,73 +0,0 @@
-import {
-  AptosApiError
-} from "./chunk-LITCPMVC.mjs";
-import {
-  VERSION
-} from "./chunk-N6K44CGJ.mjs";
-
-// src/client/core.ts
-async function request(options, client) {
-  const { url, method, body, contentType, params, overrides, originMethod } = options;
-  const headers = {
-    ...overrides?.HEADERS,
-    "x-aptos-client": `aptos-typescript-sdk/${VERSION}`,
-    "content-type": contentType ?? "application/json" /* JSON */,
-    "x-aptos-typescript-sdk-origin-method": originMethod
-  };
-  if (overrides?.AUTH_TOKEN) {
-    headers.Authorization = `Bearer ${overrides?.AUTH_TOKEN}`;
-  }
-  if (overrides?.API_KEY) {
-    headers.Authorization = `Bearer ${overrides?.API_KEY}`;
-  }
-  return client.provider({
-    url,
-    method,
-    body,
-    params,
-    headers,
-    overrides
-  });
-}
-async function aptosRequest(aptosRequestOpts, aptosConfig, apiType) {
-  const { url, path } = aptosRequestOpts;
-  const fullUrl = path ? `${url}/${path}` : url;
-  const clientResponse = await request({ ...aptosRequestOpts, url: fullUrl }, aptosConfig.client);
-  const aptosResponse = {
-    status: clientResponse.status,
-    statusText: clientResponse.statusText,
-    data: clientResponse.data,
-    headers: clientResponse.headers,
-    config: clientResponse.config,
-    request: clientResponse.request,
-    url: fullUrl
-  };
-  if (aptosResponse.status === 401) {
-    throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
-  }
-  if (apiType === "Indexer" /* INDEXER */) {
-    const indexerResponse = aptosResponse.data;
-    if (indexerResponse.errors) {
-      throw new AptosApiError({
-        apiType,
-        aptosRequest: aptosRequestOpts,
-        aptosResponse
-      });
-    }
-    aptosResponse.data = indexerResponse.data;
-  } else if (apiType === "Pepper" /* PEPPER */ || apiType === "Prover" /* PROVER */) {
-    if (aptosResponse.status >= 400) {
-      throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
-    }
-  }
-  if (aptosResponse.status >= 200 && aptosResponse.status < 300) {
-    return aptosResponse;
-  }
-  throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
-}
-
-export {
-  request,
-  aptosRequest
-};
-//# sourceMappingURL=chunk-EPUYKFAT.mjs.map

package/dist/esm/chunk-EYHRMZPO.mjs

@@ -1,34 +0,0 @@
-// src/utils/memoize.ts
-var cache = /* @__PURE__ */ new Map();
-function memoizeAsync(func, key, ttlMs) {
-  return async (...args) => {
-    if (cache.has(key)) {
-      const { value, timestamp } = cache.get(key);
-      if (ttlMs === void 0 || Date.now() - timestamp <= ttlMs) {
-        return value;
-      }
-    }
-    const result = await func(...args);
-    cache.set(key, { value: result, timestamp: Date.now() });
-    return result;
-  };
-}
-function memoize(func, key, ttlMs) {
-  return (...args) => {
-    if (cache.has(key)) {
-      const { value, timestamp } = cache.get(key);
-      if (ttlMs === void 0 || Date.now() - timestamp <= ttlMs) {
-        return value;
-      }
-    }
-    const result = func(...args);
-    cache.set(key, { value: result, timestamp: Date.now() });
-    return result;
-  };
-}
-
-export {
-  memoizeAsync,
-  memoize
-};
-//# sourceMappingURL=chunk-EYHRMZPO.mjs.map

package/dist/esm/chunk-FBF77YDQ.mjs

@@ -1,243 +0,0 @@
-import {
-  buildTransaction,
-  generateSignedTransaction,
-  generateSignedTransactionForSimulation,
-  generateTransactionPayload
-} from "./chunk-7F5TMJVQ.mjs";
-import {
-  getInfo
-} from "./chunk-JRVQNM7A.mjs";
-import {
-  Account
-} from "./chunk-EKY7QRXH.mjs";
-import {
-  MultiKeyAccount
-} from "./chunk-2CPL3GJ7.mjs";
-import {
-  KeylessAccount
-} from "./chunk-LD2CRNA2.mjs";
-import {
-  generateSigningMessageForTransaction
-} from "./chunk-LMUNGBGS.mjs";
-import {
-  RotationProofChallenge
-} from "./chunk-PNGNBHMD.mjs";
-import {
-  TypeTagU8,
-  TypeTagVector
-} from "./chunk-P3RTJ6VC.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  postAptosFullNode
-} from "./chunk-2UN35LUX.mjs";
-import {
-  MoveVector
-} from "./chunk-PSW5OBY2.mjs";
-import {
-  U8
-} from "./chunk-GWS7OLIU.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 });
-  return submitTransaction({
-    aptosConfig,
-    transaction,
-    senderAuthenticator: authenticator
-  });
-}
-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-FBF77YDQ.mjs.map

package/dist/esm/chunk-FBRETS2O.mjs

@@ -1,74 +0,0 @@
-import {
-  getDelegatedStakingActivities,
-  getNumberOfDelegators,
-  getNumberOfDelegatorsForAllPools
-} from "./chunk-AW4P5HCX.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-PSRD6U34.mjs";
-
-// src/api/staking.ts
-var Staking = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
-   *
-   * @example
-   * const delegators = await aptos.getNumberOfDelegators({poolAddress:"0x123"})
-   *
-   * @param args.poolAddress Pool address
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @returns The number of delegators for the given pool
-   */
-  async getNumberOfDelegators(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "stake_processor" /* STAKE_PROCESSOR */
-    });
-    return getNumberOfDelegators({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
-   *
-   * @example
-   * const delegators = await aptos.getNumberOfDelegatorsForAllPools()
-   *
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @returns GetNumberOfDelegatorsForAllPoolsResponse response type
-   */
-  async getNumberOfDelegatorsForAllPools(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "stake_processor" /* STAKE_PROCESSOR */
-    });
-    return getNumberOfDelegatorsForAllPools({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries delegated staking activities
-   *
-   * @example
-   * const delegators = await aptos.getDelegatedStakingActivities({delegatorAddress:"0x123",poolAddress:"0x456"})
-   *
-   * @param args.delegatorAddress Delegator address
-   * @param args.poolAddress Pool address
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-   * @returns GetDelegatedStakingActivitiesResponse response type
-   */
-  async getDelegatedStakingActivities(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "stake_processor" /* STAKE_PROCESSOR */
-    });
-    return getDelegatedStakingActivities({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  Staking
-};
-//# sourceMappingURL=chunk-FBRETS2O.mjs.map

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