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

package/dist/esm/chunk-BMXV6WQK.mjs

@@ -1,463 +0,0 @@
-import {
-  bigIntToBytesLE,
-  bytesToBigIntLE,
-  hashStrToField,
-  poseidonHash
-} from "./chunk-JWEFNE2S.mjs";
-import {
-  Proof
-} from "./chunk-IX2XMCWZ.mjs";
-import {
-  EphemeralPublicKey,
-  EphemeralSignature
-} from "./chunk-NUA7L6XF.mjs";
-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";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  memoizeAsync
-} from "./chunk-EYHRMZPO.mjs";
-import {
-  getAptosFullNode
-} from "./chunk-HCIGCJ62.mjs";
-import {
-  Deserializer
-} from "./chunk-6J7C4S3H.mjs";
-import {
-  Serializable,
-  Serializer
-} from "./chunk-UZXDD3QH.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/crypto/keyless.ts
-import { jwtDecode } from "jwt-decode";
-var EPK_HORIZON_SECS = 1e7;
-var MAX_AUD_VAL_BYTES = 120;
-var MAX_UID_KEY_BYTES = 30;
-var MAX_UID_VAL_BYTES = 330;
-var MAX_ISS_VAL_BYTES = 120;
-var MAX_EXTRA_FIELD_BYTES = 350;
-var MAX_JWT_HEADER_B64_BYTES = 300;
-var MAX_COMMITED_EPK_BYTES = 93;
-var _KeylessPublicKey = class _KeylessPublicKey extends AccountPublicKey {
-  constructor(iss, idCommitment) {
-    super();
-    const idcBytes = Hex.fromHexInput(idCommitment).toUint8Array();
-    if (idcBytes.length !== _KeylessPublicKey.ID_COMMITMENT_LENGTH) {
-      throw new Error(`Id Commitment length in bytes should be ${_KeylessPublicKey.ID_COMMITMENT_LENGTH}`);
-    }
-    this.iss = iss;
-    this.idCommitment = idcBytes;
-  }
-  /**
-   * Get the authentication key for the keyless public key
-   *
-   * @returns AuthenticationKey
-   */
-  authKey() {
-    const serializer = new Serializer();
-    serializer.serializeU32AsUleb128(3 /* Keyless */);
-    serializer.serializeFixedBytes(this.bcsToBytes());
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 2 /* SingleKey */,
-      input: serializer.toUint8Array()
-    });
-  }
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  /**
-   * Get the public key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the public key
-   */
-  toString() {
-    return Hex.fromHexInput(this.toUint8Array()).toString();
-  }
-  /**
-   * Verifies a signed data with a public key
-   *
-   * @param args.message message
-   * @param args.signature The signature
-   * @returns true if the signature is valid
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args) {
-    throw new Error("Not yet implemented");
-  }
-  serialize(serializer) {
-    serializer.serializeStr(this.iss);
-    serializer.serializeBytes(this.idCommitment);
-  }
-  static deserialize(deserializer) {
-    const iss = deserializer.deserializeStr();
-    const addressSeed = deserializer.deserializeBytes();
-    return new _KeylessPublicKey(iss, addressSeed);
-  }
-  static load(deserializer) {
-    const iss = deserializer.deserializeStr();
-    const addressSeed = deserializer.deserializeBytes();
-    return new _KeylessPublicKey(iss, addressSeed);
-  }
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _KeylessPublicKey;
-  }
-  /**
-   * Creates a KeylessPublicKey from the JWT components plus pepper
-   *
-   * @param args.iss the iss of the identity
-   * @param args.uidKey the key to use to get the uidVal in the JWT token
-   * @param args.uidVal the value of the uidKey in the JWT token
-   * @param args.aud the client ID of the application
-   * @param args.pepper The pepper used to maintain privacy of the account
-   * @returns KeylessPublicKey
-   */
-  static create(args) {
-    computeIdCommitment(args);
-    return new _KeylessPublicKey(args.iss, computeIdCommitment(args));
-  }
-  static fromJwtAndPepper(args) {
-    const { jwt, pepper, uidKey = "sub" } = args;
-    const jwtPayload = jwtDecode(jwt);
-    const iss = jwtPayload.iss;
-    if (typeof jwtPayload.aud !== "string") {
-      throw new Error("aud was not found or an array of values");
-    }
-    const aud = jwtPayload.aud;
-    const uidVal = jwtPayload[uidKey];
-    return _KeylessPublicKey.create({ iss, uidKey, uidVal, aud, pepper });
-  }
-  static isInstance(publicKey) {
-    return "iss" in publicKey && typeof publicKey.iss === "string" && "idCommitment" in publicKey && publicKey.idCommitment instanceof Uint8Array;
-  }
-};
-/**
- * The number of bytes that `idCommitment` should be
- */
-_KeylessPublicKey.ID_COMMITMENT_LENGTH = 32;
-var KeylessPublicKey = _KeylessPublicKey;
-function computeIdCommitment(args) {
-  const { uidKey, uidVal, aud, pepper } = args;
-  const fields = [
-    bytesToBigIntLE(Hex.fromHexInput(pepper).toUint8Array()),
-    hashStrToField(aud, MAX_AUD_VAL_BYTES),
-    hashStrToField(uidVal, MAX_UID_VAL_BYTES),
-    hashStrToField(uidKey, MAX_UID_KEY_BYTES)
-  ];
-  return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ID_COMMITMENT_LENGTH);
-}
-var KeylessSignature = class _KeylessSignature extends Signature {
-  constructor(args) {
-    super();
-    const { jwtHeader, ephemeralCertificate, expiryDateSecs, ephemeralPublicKey, ephemeralSignature } = args;
-    this.jwtHeader = jwtHeader;
-    this.ephemeralCertificate = ephemeralCertificate;
-    this.expiryDateSecs = expiryDateSecs;
-    this.ephemeralPublicKey = ephemeralPublicKey;
-    this.ephemeralSignature = ephemeralSignature;
-  }
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  serialize(serializer) {
-    this.ephemeralCertificate.serialize(serializer);
-    serializer.serializeStr(this.jwtHeader);
-    serializer.serializeU64(this.expiryDateSecs);
-    this.ephemeralPublicKey.serialize(serializer);
-    this.ephemeralSignature.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const ephemeralCertificate = EphemeralCertificate.deserialize(deserializer);
-    const jwtHeader = deserializer.deserializeStr();
-    const expiryDateSecs = deserializer.deserializeU64();
-    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);
-    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
-    return new _KeylessSignature({
-      jwtHeader,
-      expiryDateSecs: Number(expiryDateSecs),
-      ephemeralCertificate,
-      ephemeralPublicKey,
-      ephemeralSignature
-    });
-  }
-  static getSimulationSignature() {
-    return new _KeylessSignature({
-      jwtHeader: "{}",
-      ephemeralCertificate: new EphemeralCertificate(
-        new ZeroKnowledgeSig({
-          proof: new ZkProof(
-            new Groth16Zkp({ a: new Uint8Array(32), b: new Uint8Array(64), c: new Uint8Array(32) }),
-            0 /* Groth16 */
-          ),
-          expHorizonSecs: 0
-        }),
-        0 /* ZkProof */
-      ),
-      expiryDateSecs: 0,
-      ephemeralPublicKey: new EphemeralPublicKey(new Ed25519PublicKey(new Uint8Array(32))),
-      ephemeralSignature: new EphemeralSignature(new Ed25519Signature(new Uint8Array(64)))
-    });
-  }
-  static isSignature(signature) {
-    return signature instanceof _KeylessSignature;
-  }
-};
-var EphemeralCertificate = class _EphemeralCertificate extends Signature {
-  constructor(signature, variant) {
-    super();
-    this.signature = signature;
-    this.variant = variant;
-  }
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array() {
-    return this.signature.toUint8Array();
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.signature.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variant = deserializer.deserializeUleb128AsU32();
-    switch (variant) {
-      case 0 /* ZkProof */:
-        return new _EphemeralCertificate(ZeroKnowledgeSig.deserialize(deserializer), variant);
-      default:
-        throw new Error(`Unknown variant index for EphemeralCertificate: ${variant}`);
-    }
-  }
-};
-var G1Bytes = class _G1Bytes extends Serializable {
-  constructor(data) {
-    super();
-    this.data = Hex.fromHexInput(data).toUint8Array();
-    if (this.data.length !== 32) {
-      throw new Error("Input needs to be 32 bytes");
-    }
-  }
-  serialize(serializer) {
-    serializer.serializeFixedBytes(this.data);
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeFixedBytes(32);
-    return new _G1Bytes(bytes);
-  }
-};
-var G2Bytes = class _G2Bytes extends Serializable {
-  constructor(data) {
-    super();
-    this.data = Hex.fromHexInput(data).toUint8Array();
-    if (this.data.length !== 64) {
-      throw new Error("Input needs to be 64 bytes");
-    }
-  }
-  serialize(serializer) {
-    serializer.serializeFixedBytes(this.data);
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeFixedBytes(64);
-    return new _G2Bytes(bytes);
-  }
-};
-var Groth16Zkp = class _Groth16Zkp extends Proof {
-  constructor(args) {
-    super();
-    const { a, b, c } = args;
-    this.a = new G1Bytes(a);
-    this.b = new G2Bytes(b);
-    this.c = new G1Bytes(c);
-  }
-  serialize(serializer) {
-    this.a.serialize(serializer);
-    this.b.serialize(serializer);
-    this.c.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const a = G1Bytes.deserialize(deserializer).bcsToBytes();
-    const b = G2Bytes.deserialize(deserializer).bcsToBytes();
-    const c = G1Bytes.deserialize(deserializer).bcsToBytes();
-    return new _Groth16Zkp({ a, b, c });
-  }
-};
-var ZkProof = class _ZkProof extends Serializable {
-  constructor(proof, variant) {
-    super();
-    this.proof = proof;
-    this.variant = variant;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.proof.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variant = deserializer.deserializeUleb128AsU32();
-    switch (variant) {
-      case 0 /* Groth16 */:
-        return new _ZkProof(Groth16Zkp.deserialize(deserializer), variant);
-      default:
-        throw new Error(`Unknown variant index for ZkProof: ${variant}`);
-    }
-  }
-};
-var ZeroKnowledgeSig = class _ZeroKnowledgeSig extends Signature {
-  constructor(args) {
-    super();
-    const { proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal } = args;
-    this.proof = proof;
-    this.expHorizonSecs = expHorizonSecs;
-    this.trainingWheelsSignature = trainingWheelsSignature;
-    this.extraField = extraField;
-    this.overrideAudVal = overrideAudVal;
-  }
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  /**
-   * Return a ZeroKnowledgeSig object from its bcs serialization in bytes.
-   *
-   * @returns ZeroKnowledgeSig
-   */
-  static fromBytes(bytes) {
-    return _ZeroKnowledgeSig.deserialize(new Deserializer(bytes));
-  }
-  serialize(serializer) {
-    this.proof.serialize(serializer);
-    serializer.serializeU64(this.expHorizonSecs);
-    serializer.serializeOptionStr(this.extraField);
-    serializer.serializeOptionStr(this.overrideAudVal);
-    serializer.serializeOption(this.trainingWheelsSignature);
-  }
-  static deserialize(deserializer) {
-    const proof = ZkProof.deserialize(deserializer);
-    const expHorizonSecs = Number(deserializer.deserializeU64());
-    const extraField = deserializer.deserializeOptionStr();
-    const overrideAudVal = deserializer.deserializeOptionStr();
-    const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);
-    return new _ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
-  }
-};
-var KeylessConfiguration = class _KeylessConfiguration {
-  constructor(verficationKey, maxExpHorizonSecs) {
-    this.verficationKey = verficationKey;
-    this.maxExpHorizonSecs = maxExpHorizonSecs;
-  }
-  static create(res, maxExpHorizonSecs) {
-    return new _KeylessConfiguration(
-      new Groth16VerificationKey({
-        alphaG1: res.alpha_g1,
-        betaG2: res.beta_g2,
-        deltaG2: res.delta_g2,
-        gammaAbcG1: res.gamma_abc_g1,
-        gammaG2: res.gamma_g2
-      }),
-      maxExpHorizonSecs
-    );
-  }
-};
-var Groth16VerificationKey = class _Groth16VerificationKey {
-  constructor(args) {
-    const { alphaG1, betaG2, deltaG2, gammaAbcG1, gammaG2 } = args;
-    this.alphaG1 = new G1Bytes(alphaG1);
-    this.betaG2 = new G2Bytes(betaG2);
-    this.deltaG2 = new G2Bytes(deltaG2);
-    this.gammaAbcG1 = [new G1Bytes(gammaAbcG1[0]), new G1Bytes(gammaAbcG1[1])];
-    this.gammaG2 = new G2Bytes(gammaG2);
-  }
-  static fromGroth16VerificationKeyResponse(res) {
-    return new _Groth16VerificationKey({
-      alphaG1: res.alpha_g1,
-      betaG2: res.beta_g2,
-      deltaG2: res.delta_g2,
-      gammaAbcG1: res.gamma_abc_g1,
-      gammaG2: res.gamma_g2
-    });
-  }
-};
-async function getKeylessConfig(args) {
-  const { aptosConfig } = args;
-  return memoizeAsync(
-    async () => {
-      const config = await getKeylessConfigurationResource(args);
-      const vk = await getGroth16VerificationKeyResource(args);
-      return KeylessConfiguration.create(vk, Number(config.max_exp_horizon_secs));
-    },
-    `keyless-configuration-${aptosConfig.network}`,
-    1e3 * 60 * 5
-    // 5 minutes
-  )();
-}
-async function getKeylessConfigurationResource(args) {
-  const { aptosConfig, options } = args;
-  const resourceType = "0x1::keyless_account::Configuration";
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getKeylessConfigurationResource",
-    path: `accounts/${AccountAddress.from("0x1").toString()}/resource/${resourceType}`,
-    params: { ledger_version: options?.ledgerVersion }
-  });
-  return data.data;
-}
-async function getGroth16VerificationKeyResource(args) {
-  const { aptosConfig, options } = args;
-  const resourceType = "0x1::keyless_account::Groth16VerificationKey";
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getGroth16VerificationKeyResource",
-    path: `accounts/${AccountAddress.from("0x1").toString()}/resource/${resourceType}`,
-    params: { ledger_version: options?.ledgerVersion }
-  });
-  return data.data;
-}
-
-export {
-  EPK_HORIZON_SECS,
-  MAX_AUD_VAL_BYTES,
-  MAX_UID_KEY_BYTES,
-  MAX_UID_VAL_BYTES,
-  MAX_ISS_VAL_BYTES,
-  MAX_EXTRA_FIELD_BYTES,
-  MAX_JWT_HEADER_B64_BYTES,
-  MAX_COMMITED_EPK_BYTES,
-  KeylessPublicKey,
-  KeylessSignature,
-  EphemeralCertificate,
-  Groth16Zkp,
-  ZkProof,
-  ZeroKnowledgeSig,
-  KeylessConfiguration,
-  getKeylessConfig
-};
-//# sourceMappingURL=chunk-BMXV6WQK.mjs.map

package/dist/esm/chunk-CIPO346F.mjs

@@ -1,35 +0,0 @@
-import {
-  transferCoinTransaction
-} from "./chunk-2P7TONQL.mjs";
-
-// src/api/coin.ts
-var Coin = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Generate a transfer coin transaction that can be simulated and/or signed and submitted
-   *
-   * @example
-   * const transferCoinTransaction = await aptos.transferCoinTransaction({
-   * sender: "0x123",
-   * recipient:"0x456",
-   * amount: 10,
-   * })
-   *
-   * @param args.sender The sender account
-   * @param args.recipient The recipient address
-   * @param args.amount The amount to transfer
-   * @param args.coinType optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin
-   *
-   * @returns SimpleTransaction
-   */
-  async transferCoinTransaction(args) {
-    return transferCoinTransaction({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  Coin
-};
-//# sourceMappingURL=chunk-CIPO346F.mjs.map

package/dist/esm/chunk-CZ22MKHG.mjs

@@ -1,41 +0,0 @@
-import {
-  fundAccount
-} from "./chunk-S7KNZC2A.mjs";
-import {
-  waitForIndexer
-} from "./chunk-UZLU45X7.mjs";
-
-// src/api/faucet.ts
-var Faucet = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * This creates an account if it does not exist and mints the specified amount of
-   * coins into that account
-   *
-   * @example
-   * const transaction = await aptos.fundAccount({accountAddress:"0x123", amount: 100})
-   *
-   * @param args.accountAddress Address of the account to fund
-   * @param args.amount Amount of tokens to fund the account with
-   * @param args.options Configuration options for waitForTransaction
-   * @returns Transaction hash of the transaction that funded the account
-   */
-  async fundAccount(args) {
-    const fundTxn = await fundAccount({ aptosConfig: this.config, ...args });
-    if (args.options?.waitForIndexer === void 0 || args.options?.waitForIndexer) {
-      await waitForIndexer({
-        aptosConfig: this.config,
-        minimumLedgerVersion: BigInt(fundTxn.version),
-        processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
-      });
-    }
-    return fundTxn;
-  }
-};
-
-export {
-  Faucet
-};
-//# sourceMappingURL=chunk-CZ22MKHG.mjs.map

package/dist/esm/chunk-DNMI5PWU.mjs

@@ -1,100 +0,0 @@
-import {
-  getAccountEventsByCreationNumber,
-  getAccountEventsByEventType,
-  getEvents,
-  getModuleEventsByEventType
-} from "./chunk-FH6RKWVF.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-PSRD6U34.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-DNMI5PWU.mjs.map

package/dist/esm/chunk-DPM4FHN4.mjs

@@ -1,33 +0,0 @@
-import {
-  ValidateFeePayerDataOnSimulation
-} from "./chunk-SIJELMDP.mjs";
-import {
-  simulateTransaction
-} from "./chunk-FBF77YDQ.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-DPM4FHN4.mjs.map