@aptos-labs/ts-sdk 1.14.0-zeta.1 → 1.14.0-zeta.3

package/dist/esm/chunk-UKU6A2W2.mjs

@@ -1,232 +0,0 @@
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  Signature
-} from "./chunk-FDWJNY4U.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-FXKSE3ZP.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-UEBBLQJ5.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-UKU6A2W2.mjs.map

package/dist/esm/chunk-UX5NSZEN.mjs

@@ -1,134 +0,0 @@
-import {
-  getCurrentFungibleAssetBalances,
-  getFungibleAssetActivities,
-  getFungibleAssetMetadata,
-  transferFungibleAsset
-} from "./chunk-NYL77J4X.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-CC4DQ6NH.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
-   *
-   * 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 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-UX5NSZEN.mjs.map

package/dist/esm/chunk-VDJBDX3A.mjs

@@ -1,79 +0,0 @@
-import {
-  Ed25519Account
-} from "./chunk-KMXSRHJ6.mjs";
-import {
-  SingleKeyAccount
-} from "./chunk-JHDHNGJ3.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-RX4VG2AT.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-VDJBDX3A.mjs.map

package/dist/esm/chunk-VJP2VWMF.mjs

@@ -1,58 +0,0 @@
-import {
-  FeePayerRawTransaction,
-  MultiAgentRawTransaction
-} from "./chunk-2OQW7BMN.mjs";
-import {
-  RAW_TRANSACTION_SALT,
-  RAW_TRANSACTION_WITH_DATA_SALT
-} from "./chunk-NFJCQRVK.mjs";
-
-// src/transactions/transactionBuilder/signingMessage.ts
-import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
-function deriveTransactionType(transaction) {
-  if (transaction.feePayerAddress) {
-    return new FeePayerRawTransaction(
-      transaction.rawTransaction,
-      transaction.secondarySignerAddresses ?? [],
-      transaction.feePayerAddress
-    );
-  }
-  if (transaction.secondarySignerAddresses) {
-    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);
-  }
-  return transaction.rawTransaction;
-}
-function generateSigningMessage(bytes, domainSeparator) {
-  const hash = sha3Hash.create();
-  if (!domainSeparator.startsWith("APTOS::")) {
-    throw new Error(`Domain separator needs to start with 'APTOS::'.  Provided - ${domainSeparator}`);
-  }
-  hash.update(domainSeparator);
-  const prefix = hash.digest();
-  const body = bytes;
-  const mergedArray = new Uint8Array(prefix.length + body.length);
-  mergedArray.set(prefix);
-  mergedArray.set(body, prefix.length);
-  return mergedArray;
-}
-function generateSigningMessageForSerializable(serializable) {
-  return generateSigningMessage(serializable.bcsToBytes(), `APTOS::${serializable.constructor.name}`);
-}
-function generateSigningMessageForTransaction(transaction) {
-  const rawTxn = deriveTransactionType(transaction);
-  if (transaction.feePayerAddress) {
-    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);
-  }
-  if (transaction.secondarySignerAddresses) {
-    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);
-  }
-  return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_SALT);
-}
-
-export {
-  deriveTransactionType,
-  generateSigningMessage,
-  generateSigningMessageForSerializable,
-  generateSigningMessageForTransaction
-};
-//# sourceMappingURL=chunk-VJP2VWMF.mjs.map

package/dist/esm/chunk-VKJQORON.mjs

@@ -1,93 +0,0 @@
-import {
-  AptosApiError
-} from "./chunk-PCLNX6FS.mjs";
-import {
-  VERSION
-} from "./chunk-D2BVBXWO.mjs";
-
-// src/client/core.ts
-var errors = {
-  400: "Bad Request",
-  401: "Unauthorized",
-  403: "Forbidden",
-  404: "Not Found",
-  429: "Too Many Requests",
-  500: "Internal Server Error",
-  502: "Bad Gateway",
-  503: "Service Unavailable"
-};
-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(options, aptosConfig, apiType) {
-  const { url, path } = options;
-  const fullUrl = path ? `${url}/${path}` : url;
-  const response = await request({ ...options, url: fullUrl }, aptosConfig.client);
-  const result = {
-    status: response.status,
-    statusText: response.statusText,
-    data: response.data,
-    headers: response.headers,
-    config: response.config,
-    request: response.request,
-    url: fullUrl
-  };
-  if (result.status === 401) {
-    throw new AptosApiError(options, result, `Error: ${result.data}`);
-  }
-  if (apiType === "Indexer" /* INDEXER */) {
-    const indexerResponse = result.data;
-    if (indexerResponse.errors) {
-      throw new AptosApiError(
-        options,
-        result,
-        `Indexer error: ${indexerResponse.errors[0].message}` ?? `Indexer unhandled Error ${response.status} : ${response.statusText}`
-      );
-    }
-    result.data = indexerResponse.data;
-  }
-  if (result.status >= 200 && result.status < 300) {
-    return result;
-  }
-  if (result.status >= 500) {
-    throw new AptosApiError(options, result, `${response.data}`);
-  }
-  if (aptosConfig.isPepperServiceRequest(url) || aptosConfig.isProverServiceRequest(url)) {
-    throw new AptosApiError(options, result, `${response.data}`);
-  }
-  let errorMessage;
-  if (result && result.data && "message" in result.data && "error_code" in result.data) {
-    errorMessage = JSON.stringify(result.data);
-  } else if (result.status in errors) {
-    errorMessage = errors[result.status];
-  } else {
-    errorMessage = `Unhandled Error ${result.status} : ${result.statusText}`;
-  }
-  throw new AptosApiError(options, result, `${apiType} error: ${errorMessage}`);
-}
-
-export {
-  request,
-  aptosRequest
-};
-//# sourceMappingURL=chunk-VKJQORON.mjs.map

package/dist/esm/chunk-VPWUODU4.mjs

@@ -1,51 +0,0 @@
-import {
-  RawTransaction
-} from "./chunk-2OQW7BMN.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-
-// src/transactions/instances/simpleTransaction.ts
-var SimpleTransaction = class _SimpleTransaction extends Serializable {
-  /**
-   * SimpleTransaction represents a simple transaction type of a single signer that
-   * can be submitted to Aptos chain for execution.
-   *
-   * SimpleTransaction metadata contains the Raw Transaction and an optional
-   * sponsor Account Address to pay the gas fees.
-   *
-   * @param rawTransaction The Raw Tranasaction
-   * @param feePayerAddress The sponsor Account Address
-   */
-  constructor(rawTransaction, feePayerAddress) {
-    super();
-    this.rawTransaction = rawTransaction;
-    this.feePayerAddress = feePayerAddress;
-  }
-  serialize(serializer) {
-    this.rawTransaction.serialize(serializer);
-    if (this.feePayerAddress === void 0) {
-      serializer.serializeBool(false);
-    } else {
-      serializer.serializeBool(true);
-      this.feePayerAddress.serialize(serializer);
-    }
-  }
-  static deserialize(deserializer) {
-    const rawTransaction = RawTransaction.deserialize(deserializer);
-    const feepayerPresent = deserializer.deserializeBool();
-    let feePayerAddress;
-    if (feepayerPresent) {
-      feePayerAddress = AccountAddress.deserialize(deserializer);
-    }
-    return new _SimpleTransaction(rawTransaction, feePayerAddress);
-  }
-};
-
-export {
-  SimpleTransaction
-};
-//# sourceMappingURL=chunk-VPWUODU4.mjs.map