@digitalworld/digital-world-sdk 16.0.0

package/lib/esm/base/transaction_builder.js

@@ -0,0 +1,882 @@
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js';
+import { Hyper } from '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js';
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js';
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js';
+import '../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js';
+import 'buffer';
+import BigNumber from './util/bignumber.js';
+import types from './generated/curr_generated.js';
+import { Account } from './account.js';
+import { MuxedAccount } from './muxed_account.js';
+import { extractBaseAddress, decodeAddressToMuxedAccount } from './util/decode_encode_muxed_account.js';
+import { Transaction } from './transaction.js';
+import { FeeBumpTransaction } from './fee_bump_transaction.js';
+import { SorobanDataBuilder } from './sorobandata_builder.js';
+import { StrKey } from './strkey.js';
+import { SignerKey } from './signerkey.js';
+import { Memo } from './memo.js';
+import { nativeToScVal } from './scval.js';
+import { Operation } from './operation.js';
+import { Address } from './address.js';
+import { Keypair } from './keypair.js';
+
+const HYPER_MAX_VALUE = Hyper.MAX_VALUE;
+const UINT32_MAX = 4294967295;
+const BASE_FEE = "100";
+const TimeoutInfinite = 0;
+class TransactionBuilder {
+  source;
+  operations;
+  baseFee;
+  timebounds;
+  ledgerbounds;
+  minAccountSequence;
+  minAccountSequenceAge;
+  minAccountSequenceLedgerGap;
+  extraSigners;
+  memo;
+  networkPassphrase;
+  sorobanData;
+  /**
+   * @param sourceAccount - source account for this transaction
+   * @param opts - options object (see {@link TransactionBuilderOptions})
+   */
+  constructor(sourceAccount, opts = {}) {
+    if (!sourceAccount) {
+      throw new Error("must specify source account for the transaction");
+    }
+    if (opts.fee === void 0) {
+      throw new Error("must specify fee for the transaction (in Nats)");
+    }
+    this.source = sourceAccount;
+    this.operations = [];
+    this.baseFee = opts.fee;
+    if (opts.timebounds) {
+      const minTime = toEpochSeconds(opts.timebounds.minTime);
+      const maxTime = toEpochSeconds(opts.timebounds.maxTime);
+      if (minTime !== void 0 && minTime < 0) {
+        throw new Error("min_time cannot be negative");
+      }
+      if (maxTime !== void 0 && maxTime < 0) {
+        throw new Error("max_time cannot be negative");
+      }
+      if (minTime !== void 0 && maxTime !== void 0 && maxTime > 0 && minTime > maxTime) {
+        throw new Error("min_time cannot be greater than max_time");
+      }
+      this.timebounds = { ...opts.timebounds };
+    } else {
+      this.timebounds = null;
+    }
+    if (opts.ledgerbounds) {
+      const minLedger = opts.ledgerbounds.minLedger;
+      const maxLedger = opts.ledgerbounds.maxLedger;
+      if (minLedger !== void 0 && minLedger < 0) {
+        throw new Error("min_ledger cannot be negative");
+      }
+      if (maxLedger !== void 0 && maxLedger < 0) {
+        throw new Error("max_ledger cannot be negative");
+      }
+      if (minLedger !== void 0 && maxLedger !== void 0 && maxLedger > 0 && minLedger > maxLedger) {
+        throw new Error("min_ledger cannot be greater than max_ledger");
+      }
+      this.ledgerbounds = { ...opts.ledgerbounds };
+    } else {
+      this.ledgerbounds = null;
+    }
+    this.minAccountSequence = opts.minAccountSequence || null;
+    this.minAccountSequenceAge = opts.minAccountSequenceAge !== void 0 ? opts.minAccountSequenceAge : null;
+    this.minAccountSequenceLedgerGap = opts.minAccountSequenceLedgerGap !== void 0 ? opts.minAccountSequenceLedgerGap : null;
+    this.extraSigners = opts.extraSigners ? [...opts.extraSigners] : null;
+    this.memo = opts.memo || Memo.none();
+    this.networkPassphrase = opts.networkPassphrase || null;
+    this.sorobanData = opts.sorobanData ? new SorobanDataBuilder(opts.sorobanData).build() : null;
+  }
+  /**
+   * Creates a builder instance using an existing {@link Transaction} as a
+   * template, ignoring any existing envelope signatures.
+   *
+   * Note that the sequence number WILL be cloned, so EITHER this transaction or
+   * the one it was cloned from will be valid. This is useful in situations
+   * where you are constructing a transaction in pieces and need to make
+   * adjustments as you go (for example, when filling out Soroban resource
+   * information).
+   *
+   * @param tx - a "template" transaction to clone exactly
+   * @param opts - additional options to override the clone, e.g.
+   *    `{fee: '1000'}` will override the existing base fee derived from `tx`
+   *    (see the {@link TransactionBuilder} constructor for detailed options)
+   *
+   * **Warning:** This does not clone the transaction's
+   * {@link xdr.SorobanTransactionData} (if applicable), use
+   * {@link SorobanDataBuilder} and {@link TransactionBuilder.setSorobanData}
+   * as needed, instead.
+   *
+   * TODO: This cannot clone {@link FeeBumpTransaction}s, yet.
+   */
+  static cloneFrom(tx, opts = {}) {
+    if (!(tx instanceof Transaction)) {
+      throw new TypeError(`expected a 'Transaction', got: ${String(tx)}`);
+    }
+    const sequenceNum = (BigInt(tx.sequence) - 1n).toString();
+    let source;
+    if (StrKey.isValidMed25519PublicKey(tx.source)) {
+      source = MuxedAccount.fromAddress(tx.source, sequenceNum);
+    } else if (StrKey.isValidEd25519PublicKey(tx.source)) {
+      source = new Account(tx.source, sequenceNum);
+    } else {
+      throw new TypeError(`unsupported tx source account: ${tx.source}`);
+    }
+    if (tx.operations.length === 0) {
+      throw new Error(
+        "cannot clone a transaction with no operations: per-operation base fee cannot be determined"
+      );
+    }
+    let sorobanData;
+    const envelope = tx.toEnvelope();
+    if (envelope.switch() === types.EnvelopeType.envelopeTypeTx()) {
+      sorobanData = envelope.v1().tx().ext().value() ?? void 0;
+    }
+    let totalFee = parseInt(tx.fee, 10);
+    if (sorobanData) {
+      const resourceFee = Number(sorobanData.resourceFee().toBigInt());
+      if (totalFee - resourceFee > 0) {
+        totalFee -= resourceFee;
+      }
+    }
+    const unscaledFee = Math.floor(totalFee / tx.operations.length);
+    const builderOpts = {
+      fee: (unscaledFee || BASE_FEE).toString(),
+      memo: tx.memo,
+      networkPassphrase: tx.networkPassphrase
+    };
+    if (tx.timeBounds) {
+      builderOpts.timebounds = tx.timeBounds;
+    }
+    if (tx.ledgerBounds) {
+      builderOpts.ledgerbounds = tx.ledgerBounds;
+    }
+    if (tx.minAccountSequence) {
+      builderOpts.minAccountSequence = tx.minAccountSequence;
+    }
+    if (tx.minAccountSequenceAge !== void 0) {
+      builderOpts.minAccountSequenceAge = tx.minAccountSequenceAge;
+    }
+    if (tx.minAccountSequenceLedgerGap !== void 0) {
+      builderOpts.minAccountSequenceLedgerGap = tx.minAccountSequenceLedgerGap;
+    }
+    if (tx.extraSigners) {
+      builderOpts.extraSigners = tx.extraSigners.map(
+        (s) => SignerKey.encodeSignerKey(s)
+      );
+    }
+    Object.assign(builderOpts, opts);
+    const builder = new TransactionBuilder(source, builderOpts);
+    tx.tx.operations().forEach((op) => builder.addOperation(op));
+    return builder;
+  }
+  /**
+   * Adds an operation to the transaction.
+   *
+   * @param operation - The xdr operation object, use {@link
+   *     Operation} static methods.
+   */
+  addOperation(operation) {
+    this.operations.push(operation);
+    return this;
+  }
+  /**
+   * Adds an operation to the transaction at a specific index.
+   *
+   * @param operation - The xdr operation object to add, use {@link Operation} static methods.
+   * @param index - The index at which to insert the operation.
+   */
+  addOperationAt(operation, index) {
+    this.operations.splice(index, 0, operation);
+    return this;
+  }
+  /**
+   * Removes the operations from the builder (useful when cloning).
+   */
+  clearOperations() {
+    this.operations = [];
+    return this;
+  }
+  /**
+   * Removes the operation at the specified index from the transaction.
+   *
+   * @param index - The index of the operation to remove.
+   */
+  clearOperationAt(index) {
+    this.operations.splice(index, 1);
+    return this;
+  }
+  /**
+   * Adds a memo to the transaction.
+   * @param memo - {@link Memo} object
+   */
+  addMemo(memo) {
+    this.memo = memo;
+    return this;
+  }
+  /**
+   * Sets a timeout precondition on the transaction.
+   *
+   *  Because of the distributed nature of the Digital World Network it is possible
+   *  that the status of your transaction will be determined after a long time
+   *  if the network is highly congested. If you want to be sure to receive the
+   *  status of the transaction within a given period you should set the
+   *  time bounds with `maxTime` on the transaction (this is what `setTimeout`
+   *  does internally; if there's `minTime` set but no `maxTime` it will be
+   *  added).
+   *
+   *  A call to `TransactionBuilder.setTimeout` is **required** if Transaction
+   *  does not have `max_time` set. If you don't want to set timeout, use
+   *  {@link TimeoutInfinite}. In general you should set
+   *  {@link TimeoutInfinite} only in smart contracts.
+   *
+   *  Please note that Horizon may still return <code>504 Gateway Timeout</code>
+   *  error, even for short timeouts. In such case you need to resubmit the same
+   *  transaction again without making any changes to receive a status. This
+   *  method is using the machine system time (UTC), make sure it is set
+   *  correctly.
+   *
+   * @param timeoutSeconds - Number of seconds the transaction is good.
+   *     Can't be negative. If the value is {@link TimeoutInfinite}, the
+   *     transaction is good indefinitely.
+   *
+   * @see {@link TimeoutInfinite}
+   * @see https://docs.digitalworld.global/docs/tutorials/handling-errors/
+   */
+  setTimeout(timeoutSeconds) {
+    if (this.timebounds !== null && Number(this.timebounds.maxTime) > 0) {
+      throw new Error(
+        "TimeBounds.max_time has been already set - setting timeout would overwrite it."
+      );
+    }
+    if (timeoutSeconds < 0) {
+      throw new Error("timeout cannot be negative");
+    }
+    if (timeoutSeconds > 0) {
+      const timeoutTimestamp = Math.floor(Date.now() / 1e3) + timeoutSeconds;
+      if (this.timebounds === null) {
+        this.timebounds = { minTime: 0, maxTime: timeoutTimestamp };
+      } else {
+        this.timebounds = {
+          minTime: this.timebounds.minTime ?? 0,
+          maxTime: timeoutTimestamp
+        };
+      }
+    } else {
+      this.timebounds = {
+        minTime: 0,
+        maxTime: 0
+      };
+    }
+    return this;
+  }
+  /**
+   * If you want to prepare a transaction which will become valid at some point
+   * in the future, or be invalid after some time, you can set a timebounds
+   * precondition. Internally this will set the `minTime`, and `maxTime`
+   * preconditions. Conflicts with `setTimeout`, so use one or the other.
+   *
+   * @param minEpochOrDate - Either a JS Date object, or a number
+   *     of UNIX epoch seconds. The transaction is valid after this timestamp.
+   *     Can't be negative. If the value is `0`, the transaction is valid
+   *     immediately.
+   * @param maxEpochOrDate - Either a JS Date object, or a number
+   *     of UNIX epoch seconds. The transaction is valid until this timestamp.
+   *     Can't be negative. If the value is `0`, the transaction is valid
+   *     indefinitely.
+   */
+  setTimebounds(minEpochOrDate, maxEpochOrDate) {
+    if (typeof minEpochOrDate === "number") {
+      minEpochOrDate = new Date(minEpochOrDate * 1e3);
+    }
+    if (typeof maxEpochOrDate === "number") {
+      maxEpochOrDate = new Date(maxEpochOrDate * 1e3);
+    }
+    if (this.timebounds !== null) {
+      throw new Error(
+        "TimeBounds has been already set - setting timebounds would overwrite it."
+      );
+    }
+    const minTime = Math.floor(minEpochOrDate.valueOf() / 1e3);
+    const maxTime = Math.floor(maxEpochOrDate.valueOf() / 1e3);
+    if (minTime < 0) {
+      throw new Error("min_time cannot be negative");
+    }
+    if (maxTime < 0) {
+      throw new Error("max_time cannot be negative");
+    }
+    if (maxTime > 0 && minTime > maxTime) {
+      throw new Error("min_time cannot be greater than max_time");
+    }
+    this.timebounds = { minTime, maxTime };
+    return this;
+  }
+  /**
+   * If you want to prepare a transaction which will only be valid within some
+   * range of ledgers, you can set a ledgerbounds precondition.
+   * Internally this will set the `minLedger` and `maxLedger` preconditions.
+   *
+   * @param minLedger - The minimum ledger this transaction is valid at
+   *     or after. Cannot be negative. If the value is `0` (the default), the
+   *     transaction is valid immediately.
+   *
+   * @param maxLedger - The maximum ledger this transaction is valid
+   *     before. Cannot be negative. If the value is `0`, the transaction is
+   *     valid indefinitely.
+   */
+  setLedgerbounds(minLedger, maxLedger) {
+    if (this.ledgerbounds !== null) {
+      throw new Error(
+        "LedgerBounds has been already set - setting ledgerbounds would overwrite it."
+      );
+    }
+    if (minLedger < 0) {
+      throw new Error("min_ledger cannot be negative");
+    }
+    if (maxLedger < 0) {
+      throw new Error("max_ledger cannot be negative");
+    }
+    if (maxLedger > 0 && minLedger > maxLedger) {
+      throw new Error("min_ledger cannot be greater than max_ledger");
+    }
+    this.ledgerbounds = { minLedger, maxLedger };
+    return this;
+  }
+  /**
+   * If you want to prepare a transaction which will be valid only while the
+   * account sequence number is
+   *
+   *     `minAccountSequence <= sourceAccountSequence < tx.seqNum`
+   *
+   * Note that after execution the account's sequence number is always raised to
+   * `tx.seqNum`. Internally this will set the `minAccountSequence`
+   * precondition.
+   *
+   * @param minAccountSequence - The minimum source account sequence
+   *     number this transaction is valid for. If the value is `0` (the
+   *     default), the transaction is valid when `sourceAccount`'s sequence
+   *     number `== tx.seqNum - 1`.
+   */
+  setMinAccountSequence(minAccountSequence) {
+    if (this.minAccountSequence !== null) {
+      throw new Error(
+        "min_account_sequence has been already set - setting min_account_sequence would overwrite it."
+      );
+    }
+    this.minAccountSequence = minAccountSequence;
+    return this;
+  }
+  /**
+   * For the transaction to be valid, the current ledger time must be at least
+   * `minAccountSequenceAge` greater than sourceAccount's `sequenceTime`.
+   * Internally this will set the `minAccountSequenceAge` precondition.
+   *
+   * @param durationInSeconds - The minimum amount of time between
+   *     source account sequence time and the ledger time when this transaction
+   *     will become valid. If the value is `0`, the transaction is unrestricted
+   *     by the account sequence age. Cannot be negative.
+   */
+  setMinAccountSequenceAge(durationInSeconds) {
+    if (typeof durationInSeconds !== "bigint") {
+      throw new Error("min_account_sequence_age must be a bigint");
+    }
+    if (this.minAccountSequenceAge !== null) {
+      throw new Error(
+        "min_account_sequence_age has been already set - setting min_account_sequence_age would overwrite it."
+      );
+    }
+    if (durationInSeconds < 0) {
+      throw new Error("min_account_sequence_age cannot be negative");
+    }
+    this.minAccountSequenceAge = durationInSeconds;
+    return this;
+  }
+  /**
+   * For the transaction to be valid, the current ledger number must be at least
+   * `minAccountSequenceLedgerGap` greater than sourceAccount's ledger sequence.
+   * Internally this will set the `minAccountSequenceLedgerGap` precondition.
+   *
+   * @param gap - The minimum number of ledgers between source account
+   *     sequence and the ledger number when this transaction will become valid.
+   *     If the value is `0`, the transaction is unrestricted by the account
+   *     sequence ledger. Cannot be negative.
+   */
+  setMinAccountSequenceLedgerGap(gap) {
+    if (this.minAccountSequenceLedgerGap !== null) {
+      throw new Error(
+        "min_account_sequence_ledger_gap has been already set - setting min_account_sequence_ledger_gap would overwrite it."
+      );
+    }
+    if (gap < 0) {
+      throw new Error("min_account_sequence_ledger_gap cannot be negative");
+    }
+    this.minAccountSequenceLedgerGap = gap;
+    return this;
+  }
+  /**
+   * For the transaction to be valid, there must be a signature corresponding to
+   * every Signer in this array, even if the signature is not otherwise required
+   * by the sourceAccount or operations. Internally this will set the
+   * `extraSigners` precondition.
+   *
+   * @param extraSigners - required extra signers (as {@link StrKey}s)
+   */
+  setExtraSigners(extraSigners) {
+    if (!Array.isArray(extraSigners)) {
+      throw new Error("extra_signers must be an array of strings.");
+    }
+    if (this.extraSigners !== null) {
+      throw new Error(
+        "extra_signers has been already set - setting extra_signers would overwrite it."
+      );
+    }
+    if (extraSigners.length > 2) {
+      throw new Error("extra_signers cannot be longer than 2 elements.");
+    }
+    this.extraSigners = [...extraSigners];
+    return this;
+  }
+  /**
+   * Set network passphrase for the Transaction that will be built.
+   *
+   * @param networkPassphrase - passphrase of the target Digital World
+   *     network (e.g. "Digital World Network ; June 2021").
+   */
+  setNetworkPassphrase(networkPassphrase) {
+    this.networkPassphrase = networkPassphrase;
+    return this;
+  }
+  /**
+   * Sets the transaction's internal Soroban transaction data (resources,
+   * footprint, etc.).
+   *
+   * For non-contract(non-Soroban) transactions, this setting has no effect. In
+   * the case of Soroban transactions, this is either an instance of
+   * {@link xdr.SorobanTransactionData} or a base64-encoded string of said
+   * structure. This is usually obtained from the simulation response based on a
+   * transaction with a Soroban operation (e.g.
+   * {@link Operation.invokeHostFunction}, providing necessary resource
+   * and storage footprint estimations for contract invocation.
+   *
+   * @param sorobanData - the {@link xdr.SorobanTransactionData} as a raw xdr
+   *    object or a base64 string to be decoded
+   *
+   * @see {@link SorobanDataBuilder}
+   */
+  setSorobanData(sorobanData) {
+    this.sorobanData = new SorobanDataBuilder(sorobanData).build();
+    return this;
+  }
+  /**
+   * Creates and adds an invoke host function operation for transferring SAC tokens.
+   * This method removes the need for simulation by handling the creation of the
+   * appropriate authorization entries and ledger footprint for the transfer operation.
+   *
+   * @param destination - the address of the recipient of the SAC transfer (should be a valid Digital World address or contract ID)
+   * @param asset - the SAC asset to be transferred
+   * @param amount - the amount of tokens to be transferred in 7 decimals. IE 1 token with 7 decimals of precision would be represented as "1_0000000"
+   * @param sorobanFees - optional Soroban fees for the transaction to override the default fees used
+   */
+  addSacTransferOperation(destination, asset, amount, sorobanFees) {
+    if (BigInt(amount) <= 0n) {
+      throw new Error("Amount must be a positive integer");
+    } else if (BigInt(amount) > HYPER_MAX_VALUE) {
+      throw new Error("Amount exceeds maximum value for i64");
+    }
+    if (sorobanFees) {
+      const { instructions, readBytes, writeBytes, resourceFee } = sorobanFees;
+      const U32_MAX = 4294967295;
+      if (instructions <= 0 || instructions > U32_MAX) {
+        throw new Error(
+          `instructions must be greater than 0 and at most ${U32_MAX}`
+        );
+      }
+      if (readBytes <= 0 || readBytes > U32_MAX) {
+        throw new Error(
+          `readBytes must be greater than 0 and at most ${U32_MAX}`
+        );
+      }
+      if (writeBytes <= 0 || writeBytes > U32_MAX) {
+        throw new Error(
+          `writeBytes must be greater than 0 and at most ${U32_MAX}`
+        );
+      }
+      if (resourceFee <= 0n || resourceFee > HYPER_MAX_VALUE) {
+        throw new Error(
+          "resourceFee must be greater than 0 and at most i64 max"
+        );
+      }
+    }
+    const isDestinationContract = StrKey.isValidContract(destination);
+    if (!isDestinationContract) {
+      if (!StrKey.isValidEd25519PublicKey(destination) && !StrKey.isValidMed25519PublicKey(destination)) {
+        throw new Error(
+          "Invalid destination address. Must be a valid Digital World address or contract ID."
+        );
+      }
+    }
+    const destinationBaseAddress = isDestinationContract ? destination : extractBaseAddress(destination);
+    if (destinationBaseAddress === extractBaseAddress(this.source.accountId())) {
+      throw new Error("Destination cannot be the same as the source account.");
+    }
+    if (this.networkPassphrase === null) {
+      throw new Error(
+        "networkPassphrase must be set to add a SAC transfer operation"
+      );
+    }
+    const contractId = asset.contractId(this.networkPassphrase);
+    const functionName = "transfer";
+    const source = this.source.accountId();
+    const sourceBaseAddress = extractBaseAddress(source);
+    const args = [
+      nativeToScVal(source, { type: "address" }),
+      nativeToScVal(destination, { type: "address" }),
+      nativeToScVal(amount, { type: "i128" })
+    ];
+    const isAssetNative = asset.isNative();
+    const auths = new types.SorobanAuthorizationEntry({
+      credentials: types.SorobanCredentials.sorobanCredentialsSourceAccount(),
+      rootInvocation: new types.SorobanAuthorizedInvocation({
+        function: types.SorobanAuthorizedFunction.sorobanAuthorizedFunctionTypeContractFn(
+          new types.InvokeContractArgs({
+            contractAddress: Address.fromString(contractId).toScAddress(),
+            functionName,
+            args
+          })
+        ),
+        subInvocations: []
+      })
+    });
+    const footprint = new types.LedgerFootprint({
+      readOnly: [
+        types.LedgerKey.contractData(
+          new types.LedgerKeyContractData({
+            contract: Address.fromString(contractId).toScAddress(),
+            key: types.ScVal.scvLedgerKeyContractInstance(),
+            durability: types.ContractDataDurability.persistent()
+          })
+        )
+      ],
+      readWrite: []
+    });
+    if (isDestinationContract) {
+      footprint.readWrite().push(
+        types.LedgerKey.contractData(
+          new types.LedgerKeyContractData({
+            contract: Address.fromString(contractId).toScAddress(),
+            key: types.ScVal.scvVec([
+              nativeToScVal("Balance", { type: "symbol" }),
+              nativeToScVal(destination, { type: "address" })
+            ]),
+            durability: types.ContractDataDurability.persistent()
+          })
+        )
+      );
+      if (!isAssetNative) {
+        const assetIssuer = asset.getIssuer();
+        if (!assetIssuer) {
+          throw new Error("Asset issuer must be set for non-native assets.");
+        }
+        footprint.readOnly().push(
+          types.LedgerKey.account(
+            new types.LedgerKeyAccount({
+              accountId: Keypair.fromPublicKey(assetIssuer).xdrPublicKey()
+            })
+          )
+        );
+      }
+    } else if (isAssetNative) {
+      footprint.readWrite().push(
+        types.LedgerKey.account(
+          new types.LedgerKeyAccount({
+            accountId: Keypair.fromPublicKey(
+              destinationBaseAddress
+            ).xdrPublicKey()
+          })
+        )
+      );
+    } else if (asset.getIssuer() !== destinationBaseAddress) {
+      footprint.readWrite().push(
+        types.LedgerKey.trustline(
+          new types.LedgerKeyTrustLine({
+            accountId: Keypair.fromPublicKey(
+              destinationBaseAddress
+            ).xdrPublicKey(),
+            asset: asset.toTrustLineXDRObject()
+          })
+        )
+      );
+    }
+    if (asset.isNative()) {
+      footprint.readWrite().push(
+        types.LedgerKey.account(
+          new types.LedgerKeyAccount({
+            accountId: Keypair.fromPublicKey(sourceBaseAddress).xdrPublicKey()
+          })
+        )
+      );
+    } else if (asset.getIssuer() !== sourceBaseAddress) {
+      footprint.readWrite().push(
+        types.LedgerKey.trustline(
+          new types.LedgerKeyTrustLine({
+            accountId: Keypair.fromPublicKey(sourceBaseAddress).xdrPublicKey(),
+            asset: asset.toTrustLineXDRObject()
+          })
+        )
+      );
+    }
+    const defaultPaymentFees = {
+      instructions: 4e5,
+      readBytes: 1e3,
+      writeBytes: 1e3,
+      resourceFee: BigInt(5e6)
+    };
+    const sorobanData = new types.SorobanTransactionData({
+      resources: new types.SorobanResources({
+        footprint,
+        instructions: sorobanFees ? sorobanFees.instructions : defaultPaymentFees.instructions,
+        diskReadBytes: sorobanFees ? sorobanFees.readBytes : defaultPaymentFees.readBytes,
+        writeBytes: sorobanFees ? sorobanFees.writeBytes : defaultPaymentFees.writeBytes
+      }),
+      ext: new types.SorobanTransactionDataExt(0),
+      resourceFee: new types.Int64(
+        sorobanFees ? sorobanFees.resourceFee : defaultPaymentFees.resourceFee
+      )
+    });
+    const operation = Operation.invokeContractFunction({
+      contract: contractId,
+      function: functionName,
+      args,
+      auth: [auths]
+    });
+    this.setSorobanData(sorobanData);
+    return this.addOperation(operation);
+  }
+  /**
+   * Builds the transaction and increments the source account's sequence
+   * number by 1.
+   */
+  build() {
+    const sequenceNumber = new BigNumber(this.source.sequenceNumber()).plus(1);
+    const fee = new BigNumber(this.baseFee).times(this.operations.length).toNumber();
+    if (fee > UINT32_MAX) {
+      throw new Error(
+        `Total fee (baseFee * operations) exceeds the maximum uint32 value (${UINT32_MAX}). Got ${fee} from baseFee=${this.baseFee} and ${this.operations.length} operation(s).`
+      );
+    }
+    const attrs = {
+      fee,
+      seqNum: types.Int64.fromString(sequenceNumber.toString()),
+      memo: this.memo ? this.memo.toXDRObject() : null
+    };
+    if (this.timebounds === null || typeof this.timebounds.minTime === "undefined" || typeof this.timebounds.maxTime === "undefined") {
+      throw new Error(
+        "TimeBounds has to be set or you must call setTimeout(TimeoutInfinite)."
+      );
+    }
+    if (isValidDate(this.timebounds.minTime)) {
+      this.timebounds.minTime = Math.floor(
+        this.timebounds.minTime.getTime() / 1e3
+      );
+    }
+    if (isValidDate(this.timebounds.maxTime)) {
+      this.timebounds.maxTime = Math.floor(
+        this.timebounds.maxTime.getTime() / 1e3
+      );
+    }
+    const minTime = types.Uint64.fromString(this.timebounds.minTime.toString());
+    const maxTime = types.Uint64.fromString(this.timebounds.maxTime.toString());
+    const timeBounds = new types.TimeBounds({ minTime, maxTime });
+    if (this.hasV2Preconditions()) {
+      let ledgerBounds = null;
+      if (this.ledgerbounds !== null) {
+        ledgerBounds = new types.LedgerBounds({
+          minLedger: this.ledgerbounds.minLedger ?? 0,
+          maxLedger: this.ledgerbounds.maxLedger ?? 0
+        });
+      }
+      const minSeqNum = this.minAccountSequence ? types.Int64.fromString(this.minAccountSequence) : null;
+      const minSeqAge = types.Uint64.fromString(
+        this.minAccountSequenceAge !== null ? this.minAccountSequenceAge.toString() : "0"
+      );
+      const minSeqLedgerGap = this.minAccountSequenceLedgerGap || 0;
+      const extraSigners = this.extraSigners !== null ? this.extraSigners.map((s) => SignerKey.decodeAddress(s)) : [];
+      attrs.cond = types.Preconditions.precondV2(
+        new types.PreconditionsV2({
+          timeBounds,
+          ledgerBounds,
+          minSeqNum,
+          minSeqAge,
+          minSeqLedgerGap,
+          extraSigners
+        })
+      );
+    } else {
+      attrs.cond = types.Preconditions.precondTime(timeBounds);
+    }
+    attrs.sourceAccount = decodeAddressToMuxedAccount(this.source.accountId());
+    if (this.sorobanData) {
+      attrs.ext = new types.TransactionExt(1, this.sorobanData);
+      attrs.fee = new BigNumber(attrs.fee).plus(this.sorobanData.resourceFee().toString()).toNumber();
+      if (attrs.fee > UINT32_MAX) {
+        throw new Error(
+          `Total fee (baseFee * operations + resourceFee) exceeds the maximum uint32 value (${UINT32_MAX}). Got ${attrs.fee}.`
+        );
+      }
+    } else {
+      attrs.ext = new types.TransactionExt(0);
+    }
+    const xtx = new types.Transaction(
+      attrs
+    );
+    xtx.operations(this.operations);
+    const txEnvelope = types.TransactionEnvelope.envelopeTypeTx(
+      new types.TransactionV1Envelope({ tx: xtx, signatures: [] })
+    );
+    if (this.networkPassphrase === null) {
+      throw new Error("networkPassphrase must be set to build a transaction");
+    }
+    const tx = new Transaction(txEnvelope, this.networkPassphrase);
+    this.source.incrementSequenceNumber();
+    return tx;
+  }
+  /**
+   * Checks whether any v2 preconditions have been set on this builder.
+   */
+  hasV2Preconditions() {
+    return this.ledgerbounds !== null || this.minAccountSequence !== null || this.minAccountSequenceAge !== null || this.minAccountSequenceLedgerGap !== null || this.extraSigners !== null && this.extraSigners.length > 0;
+  }
+  /**
+   * Builds a {@link FeeBumpTransaction}, enabling you to resubmit an existing
+   * transaction with a higher fee.
+   *
+   * @param feeSource - account paying for the transaction,
+   *     in the form of either a Keypair (only the public key is used) or
+   *     an account ID (in G... or M... form, but refer to `withMuxing`)
+   * @param baseFee - max fee willing to pay per operation
+   *     in inner transaction (**in Nats**)
+   * @param innerTx - {@link Transaction} to be bumped by
+   *     the fee bump transaction
+   * @param networkPassphrase - passphrase of the target
+   *     Digital World network (e.g. "Digital World Network ; June 2021",
+   *     see {@link Networks})
+   *
+   * TODO: Alongside the next major version bump, this type signature can be
+   *       changed to be less awkward: accept a MuxedAccount as the `feeSource`
+   *       rather than a keypair or string.
+   *
+   * Your fee-bump amount should be `>= 10x` the original fee.
+   * @see  https://docs.digitalworld.global/docs/glossary/fee-bumps/#replace-by-fee
+   */
+  static buildFeeBumpTransaction(feeSource, baseFee, innerTx, networkPassphrase) {
+    const innerOps = innerTx.operations.length;
+    const minBaseFee = new BigNumber(BASE_FEE);
+    let resourceFee = new BigNumber(0);
+    const env = innerTx.toEnvelope();
+    switch (env.switch().value) {
+      case types.EnvelopeType.envelopeTypeTx().value: {
+        const sorobanData = env.v1().tx().ext().value();
+        resourceFee = new BigNumber(sorobanData?.resourceFee().toString() ?? 0);
+        break;
+      }
+    }
+    const innerInclusionFee = new BigNumber(innerTx.fee).minus(resourceFee).div(innerOps);
+    const base = new BigNumber(baseFee);
+    if (base.lt(innerInclusionFee)) {
+      throw new Error(
+        `Invalid baseFee, it should be at least ${innerInclusionFee.toString()} Nats.`
+      );
+    }
+    if (base.lt(minBaseFee)) {
+      throw new Error(
+        `Invalid baseFee, it should be at least ${minBaseFee.toString()} Nats.`
+      );
+    }
+    let innerTxEnvelope = innerTx.toEnvelope();
+    if (innerTxEnvelope.switch() === types.EnvelopeType.envelopeTypeTxV0()) {
+      const v0Tx = innerTxEnvelope.v0().tx();
+      const v0TimeBounds = v0Tx.timeBounds();
+      if (v0TimeBounds === null) {
+        throw new Error("Inner transaction must have time bounds");
+      }
+      const v1Tx = new types.Transaction({
+        sourceAccount: types.MuxedAccount.keyTypeEd25519(
+          v0Tx.sourceAccountEd25519()
+        ),
+        fee: v0Tx.fee(),
+        seqNum: v0Tx.seqNum(),
+        cond: types.Preconditions.precondTime(v0TimeBounds),
+        memo: v0Tx.memo(),
+        operations: v0Tx.operations(),
+        ext: new types.TransactionExt(0)
+      });
+      innerTxEnvelope = types.TransactionEnvelope.envelopeTypeTx(
+        new types.TransactionV1Envelope({
+          tx: v1Tx,
+          signatures: innerTxEnvelope.v0().signatures()
+        })
+      );
+    }
+    let feeSourceAccount;
+    if (typeof feeSource === "string") {
+      feeSourceAccount = decodeAddressToMuxedAccount(feeSource);
+    } else {
+      feeSourceAccount = feeSource.xdrMuxedAccount();
+    }
+    const tx = new types.FeeBumpTransaction({
+      feeSource: feeSourceAccount,
+      fee: types.Int64.fromString(
+        base.times(innerOps + 1).plus(resourceFee).toString()
+      ),
+      innerTx: types.FeeBumpTransactionInnerTx.envelopeTypeTx(
+        innerTxEnvelope.v1()
+      ),
+      ext: new types.FeeBumpTransactionExt(0)
+    });
+    const feeBumpTxEnvelope = new types.FeeBumpTransactionEnvelope({
+      tx,
+      signatures: []
+    });
+    const envelope = types.TransactionEnvelope.envelopeTypeTxFeeBump(feeBumpTxEnvelope);
+    return new FeeBumpTransaction(envelope, networkPassphrase);
+  }
+  /**
+   * Build a {@link Transaction} or {@link FeeBumpTransaction} from an
+   * xdr.TransactionEnvelope.
+   *
+   * @param envelope - The transaction envelope
+   *     object or base64 encoded string.
+   * @param networkPassphrase - The network passphrase of the target
+   *     Digital World network (e.g. "Digital World Network ; June 2021"),
+   *     see {@link Networks}.
+   */
+  static fromXDR(envelope, networkPassphrase) {
+    if (typeof envelope === "string") {
+      envelope = types.TransactionEnvelope.fromXDR(envelope, "base64");
+    }
+    if (envelope.switch() === types.EnvelopeType.envelopeTypeTxFeeBump()) {
+      return new FeeBumpTransaction(envelope, networkPassphrase);
+    }
+    return new Transaction(envelope, networkPassphrase);
+  }
+}
+function isValidDate(d) {
+  return d instanceof Date && !Number.isNaN(d.getTime());
+}
+function toEpochSeconds(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const num = value instanceof Date ? Math.floor(value.getTime() / 1e3) : Number(value);
+  if (!Number.isFinite(num) || num % 1 !== 0) {
+    throw new Error("timebounds value must be a finite integer or Date");
+  }
+  return num;
+}
+
+export { BASE_FEE, TimeoutInfinite, TransactionBuilder, isValidDate };
+//# sourceMappingURL=transaction_builder.js.map