@digitalworld/digital-world-sdk 16.0.0

package/lib/esm/base/transaction_base.js

@@ -0,0 +1,203 @@
+import { Buffer } from 'buffer';
+import types from './generated/curr_generated.js';
+import { hash } from './hashing.js';
+import { Keypair } from './keypair.js';
+
+class TransactionBase {
+  _tx;
+  _signatures;
+  _fee;
+  _networkPassphrase;
+  constructor(tx, signatures, fee, networkPassphrase) {
+    if (typeof networkPassphrase !== "string") {
+      throw new Error(
+        `Invalid passphrase provided to Transaction: expected a string but got a ${typeof networkPassphrase}`
+      );
+    }
+    this._networkPassphrase = networkPassphrase;
+    this._tx = tx;
+    this._signatures = signatures;
+    this._fee = fee;
+  }
+  /** The list of signatures for this transaction. */
+  get signatures() {
+    return this._signatures;
+  }
+  set signatures(_value) {
+    throw new Error("Transaction is immutable");
+  }
+  /**
+   * The underlying XDR transaction object.
+   *
+   * Returns a defensive copy so that external mutations cannot alter the
+   * transaction that will be signed or serialized.
+   *
+   * @throws if the internal transaction is not a recognized XDR type
+   */
+  get tx() {
+    const buf = this._tx.toXDR();
+    if (this._tx instanceof types.Transaction) {
+      return types.Transaction.fromXDR(buf);
+    }
+    if (this._tx instanceof types.TransactionV0) {
+      return types.TransactionV0.fromXDR(buf);
+    }
+    if (this._tx instanceof types.FeeBumpTransaction) {
+      return types.FeeBumpTransaction.fromXDR(buf);
+    }
+    throw new Error("Unknown transaction type");
+  }
+  set tx(_value) {
+    throw new Error("Transaction is immutable");
+  }
+  /** The total fee for this transaction, in Nats. */
+  get fee() {
+    return this._fee;
+  }
+  set fee(_value) {
+    throw new Error("Transaction is immutable");
+  }
+  /** The network passphrase for this transaction. */
+  get networkPassphrase() {
+    return this._networkPassphrase;
+  }
+  set networkPassphrase(_networkPassphrase) {
+    throw new Error("Transaction is immutable");
+  }
+  /**
+   * Signs the transaction with the given {@link Keypair}.
+   * @param keypairs - Keypairs of signers
+   */
+  sign(...keypairs) {
+    const txHash = this.hash();
+    keypairs.forEach((kp) => {
+      const sig = kp.signDecorated(txHash);
+      this.signatures.push(sig);
+    });
+  }
+  /**
+   * Signs a transaction with the given {@link Keypair}. Useful if someone sends
+   * you a transaction XDR for you to sign and return (see
+   * `{@link Transaction.addSignature | addSignature}` for more information).
+   *
+   * When you get a transaction XDR to sign....
+   * - Instantiate a `Transaction` object with the XDR
+   * - Use {@link Keypair} to generate a keypair object for your Digital World secret seed.
+   * - Run `getKeypairSignature` with that keypair
+   * - Send back the signature along with your publicKey (not your secret seed!)
+   *
+   * Example:
+   * ```javascript
+   * // `transactionXDR` is a string from the person generating the transaction
+   * const transaction = new Transaction(transactionXDR, networkPassphrase);
+   * const keypair = Keypair.fromSecret(myDigitalWorldSeed);
+   * return transaction.getKeypairSignature(keypair);
+   * ```
+   *
+   * Returns the base64-encoded signature string for the given keypair.
+   *
+   * @param keypair - Keypair of signer
+   */
+  getKeypairSignature(keypair) {
+    return keypair.sign(this.hash()).toString("base64");
+  }
+  /**
+   * Add a signature to the transaction. Useful when a party wants to pre-sign
+   * a transaction but doesn't want to give access to their secret keys.
+   * This will also verify whether the signature is valid.
+   *
+   * Here's how you would use this feature to solicit multiple signatures.
+   * - Use `TransactionBuilder` to build a new transaction.
+   * - Make sure to set a long enough timeout on that transaction to give your
+   * signers enough time to sign!
+   * - Once you build the transaction, use `transaction.toXDR()` to get the
+   * base64-encoded XDR string.
+   * - _Warning!_ Once you've built this transaction, don't submit any other
+   * transactions onto your account! Doing so will invalidate this pre-compiled
+   * transaction!
+   * - Send this XDR string to your other parties. They can use the instructions
+   * for `{@link Transaction.getKeypairSignature | getKeypairSignature}` to sign the transaction.
+   * - They should send you back their `publicKey` and the `signature` string
+   * from `{@link Transaction.getKeypairSignature | getKeypairSignature}`, both of which you pass to
+   * this function.
+   *
+   * @param publicKey - the public key of the signer
+   * @param signature - the base64 value of the signature XDR
+   */
+  addSignature(publicKey = "", signature = "") {
+    if (!signature || typeof signature !== "string") {
+      throw new Error("Invalid signature");
+    }
+    if (!publicKey || typeof publicKey !== "string") {
+      throw new Error("Invalid publicKey");
+    }
+    let keypair;
+    let hint;
+    const signatureBuffer = Buffer.from(signature, "base64");
+    try {
+      keypair = Keypair.fromPublicKey(publicKey);
+      hint = keypair.signatureHint();
+    } catch {
+      throw new Error("Invalid publicKey");
+    }
+    if (!keypair.verify(this.hash(), signatureBuffer)) {
+      throw new Error("Invalid signature");
+    }
+    this.signatures.push(
+      new types.DecoratedSignature({
+        hint,
+        signature: signatureBuffer
+      })
+    );
+  }
+  /**
+   * Add a decorated signature directly to the transaction envelope.
+   *
+   * @param signature - raw signature to add
+   *
+   * @see Keypair.signDecorated
+   * @see Keypair.signPayloadDecorated
+   */
+  addDecoratedSignature(signature) {
+    this.signatures.push(signature);
+  }
+  /**
+   * Add `hashX` signer preimage as signature.
+   * @param preimage - preimage of hash used as signer
+   */
+  signHashX(preimage) {
+    if (typeof preimage === "string") {
+      preimage = Buffer.from(preimage, "hex");
+    }
+    if (preimage.length > 64) {
+      throw new Error("preimage cannot be longer than 64 bytes");
+    }
+    const signature = preimage;
+    const hashX = hash(preimage);
+    const hint = hashX.subarray(hashX.length - 4);
+    this.signatures.push(new types.DecoratedSignature({ hint, signature }));
+  }
+  /**
+   * Returns a hash for this transaction, suitable for signing.
+   */
+  hash() {
+    return hash(this.signatureBase());
+  }
+  /** Returns the signature base for this transaction, to be overridden by subclasses. */
+  signatureBase() {
+    throw new Error("Implement in subclass");
+  }
+  /** Returns the XDR transaction envelope, to be overridden by subclasses. */
+  toEnvelope() {
+    throw new Error("Implement in subclass");
+  }
+  /**
+   * Returns the transaction envelope as a base64-encoded XDR string.
+   */
+  toXDR() {
+    return this.toEnvelope().toXDR().toString("base64");
+  }
+}
+
+export { TransactionBase };
+//# sourceMappingURL=transaction_base.js.map

package/lib/esm/base/transaction_base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction_base.js","sources":["../../../src/base/transaction_base.ts"],"sourcesContent":["import xdr from \"./xdr.js\";\nimport { hash } from \"./hashing.js\";\nimport { Keypair } from \"./keypair.js\";\n\n/**\n * @ignore\n */\nexport class TransactionBase<\n  TTx extends xdr.FeeBumpTransaction | xdr.Transaction | xdr.TransactionV0,\n> {\n  private _tx: TTx;\n  private _signatures: xdr.DecoratedSignature[];\n  private _fee: string;\n  private _networkPassphrase: string;\n\n  constructor(\n    tx: TTx,\n    signatures: xdr.DecoratedSignature[],\n    fee: string,\n    networkPassphrase: string,\n  ) {\n    if (typeof networkPassphrase !== \"string\") {\n      throw new Error(\n        `Invalid passphrase provided to Transaction: expected a string but got a ${typeof networkPassphrase}`,\n      );\n    }\n\n    this._networkPassphrase = networkPassphrase;\n    this._tx = tx;\n    this._signatures = signatures;\n    this._fee = fee;\n  }\n\n  /** The list of signatures for this transaction. */\n  get signatures(): xdr.DecoratedSignature[] {\n    return this._signatures;\n  }\n\n  set signatures(_value: xdr.DecoratedSignature[]) {\n    throw new Error(\"Transaction is immutable\");\n  }\n\n  /**\n   * The underlying XDR transaction object.\n   *\n   * Returns a defensive copy so that external mutations cannot alter the\n   * transaction that will be signed or serialized.\n   *\n   * @throws if the internal transaction is not a recognized XDR type\n   */\n  get tx(): TTx {\n    const buf = this._tx.toXDR();\n\n    // Making sure we have the right type here, since the base class doesn't\n    // know which transaction type it is.\n    if (this._tx instanceof xdr.Transaction) {\n      return xdr.Transaction.fromXDR(buf) as TTx;\n    }\n\n    if (this._tx instanceof xdr.TransactionV0) {\n      return xdr.TransactionV0.fromXDR(buf) as TTx;\n    }\n\n    if (this._tx instanceof xdr.FeeBumpTransaction) {\n      return xdr.FeeBumpTransaction.fromXDR(buf) as TTx;\n    }\n\n    throw new Error(\"Unknown transaction type\");\n  }\n\n  set tx(_value: TTx) {\n    throw new Error(\"Transaction is immutable\");\n  }\n\n  /** The total fee for this transaction, in Nats. */\n  get fee(): string {\n    return this._fee;\n  }\n\n  set fee(_value: string) {\n    throw new Error(\"Transaction is immutable\");\n  }\n\n  /** The network passphrase for this transaction. */\n  get networkPassphrase(): string {\n    return this._networkPassphrase;\n  }\n\n  set networkPassphrase(_networkPassphrase: string) {\n    throw new Error(\"Transaction is immutable\");\n  }\n\n  /**\n   * Signs the transaction with the given {@link Keypair}.\n   * @param keypairs - Keypairs of signers\n   */\n  sign(...keypairs: Keypair[]): void {\n    const txHash = this.hash();\n\n    keypairs.forEach((kp) => {\n      const sig = kp.signDecorated(txHash);\n      this.signatures.push(sig);\n    });\n  }\n\n  /**\n   * Signs a transaction with the given {@link Keypair}. Useful if someone sends\n   * you a transaction XDR for you to sign and return (see\n   * `{@link Transaction.addSignature | addSignature}` for more information).\n   *\n   * When you get a transaction XDR to sign....\n   * - Instantiate a `Transaction` object with the XDR\n   * - Use {@link Keypair} to generate a keypair object for your Digital World secret seed.\n   * - Run `getKeypairSignature` with that keypair\n   * - Send back the signature along with your publicKey (not your secret seed!)\n   *\n   * Example:\n   * ```javascript\n   * // `transactionXDR` is a string from the person generating the transaction\n   * const transaction = new Transaction(transactionXDR, networkPassphrase);\n   * const keypair = Keypair.fromSecret(myDigitalWorldSeed);\n   * return transaction.getKeypairSignature(keypair);\n   * ```\n   *\n   * Returns the base64-encoded signature string for the given keypair.\n   *\n   * @param keypair - Keypair of signer\n   */\n  getKeypairSignature(keypair: Keypair): string {\n    return keypair.sign(this.hash()).toString(\"base64\");\n  }\n\n  /**\n   * Add a signature to the transaction. Useful when a party wants to pre-sign\n   * a transaction but doesn't want to give access to their secret keys.\n   * This will also verify whether the signature is valid.\n   *\n   * Here's how you would use this feature to solicit multiple signatures.\n   * - Use `TransactionBuilder` to build a new transaction.\n   * - Make sure to set a long enough timeout on that transaction to give your\n   * signers enough time to sign!\n   * - Once you build the transaction, use `transaction.toXDR()` to get the\n   * base64-encoded XDR string.\n   * - _Warning!_ Once you've built this transaction, don't submit any other\n   * transactions onto your account! Doing so will invalidate this pre-compiled\n   * transaction!\n   * - Send this XDR string to your other parties. They can use the instructions\n   * for `{@link Transaction.getKeypairSignature | getKeypairSignature}` to sign the transaction.\n   * - They should send you back their `publicKey` and the `signature` string\n   * from `{@link Transaction.getKeypairSignature | getKeypairSignature}`, both of which you pass to\n   * this function.\n   *\n   * @param publicKey - the public key of the signer\n   * @param signature - the base64 value of the signature XDR\n   */\n  addSignature(publicKey = \"\", signature = \"\"): void {\n    if (!signature || typeof signature !== \"string\") {\n      throw new Error(\"Invalid signature\");\n    }\n\n    if (!publicKey || typeof publicKey !== \"string\") {\n      throw new Error(\"Invalid publicKey\");\n    }\n\n    let keypair;\n    let hint;\n    const signatureBuffer = Buffer.from(signature, \"base64\");\n\n    try {\n      keypair = Keypair.fromPublicKey(publicKey);\n      hint = keypair.signatureHint();\n    } catch {\n      throw new Error(\"Invalid publicKey\");\n    }\n\n    if (!keypair.verify(this.hash(), signatureBuffer)) {\n      throw new Error(\"Invalid signature\");\n    }\n\n    this.signatures.push(\n      new xdr.DecoratedSignature({\n        hint,\n        signature: signatureBuffer,\n      }),\n    );\n  }\n\n  /**\n   * Add a decorated signature directly to the transaction envelope.\n   *\n   * @param signature - raw signature to add\n   *\n   * @see Keypair.signDecorated\n   * @see Keypair.signPayloadDecorated\n   */\n  addDecoratedSignature(signature: xdr.DecoratedSignature): void {\n    this.signatures.push(signature);\n  }\n\n  /**\n   * Add `hashX` signer preimage as signature.\n   * @param preimage - preimage of hash used as signer\n   */\n  signHashX(preimage: Buffer | string): void {\n    if (typeof preimage === \"string\") {\n      preimage = Buffer.from(preimage, \"hex\");\n    }\n\n    if (preimage.length > 64) {\n      throw new Error(\"preimage cannot be longer than 64 bytes\");\n    }\n\n    const signature = preimage;\n    const hashX = hash(preimage);\n    const hint = hashX.subarray(hashX.length - 4);\n    this.signatures.push(new xdr.DecoratedSignature({ hint, signature }));\n  }\n\n  /**\n   * Returns a hash for this transaction, suitable for signing.\n   */\n  hash(): Buffer {\n    return hash(this.signatureBase());\n  }\n\n  /** Returns the signature base for this transaction, to be overridden by subclasses. */\n  signatureBase(): Buffer {\n    throw new Error(\"Implement in subclass\");\n  }\n\n  /** Returns the XDR transaction envelope, to be overridden by subclasses. */\n  toEnvelope(): xdr.TransactionEnvelope {\n    throw new Error(\"Implement in subclass\");\n  }\n\n  /**\n   * Returns the transaction envelope as a base64-encoded XDR string.\n   */\n  toXDR(): string {\n    return this.toEnvelope().toXDR().toString(\"base64\");\n  }\n}\n"],"names":["xdr"],"mappings":"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"}

package/lib/esm/base/transaction_builder.d.ts

@@ -0,0 +1,394 @@
+import xdr from "./xdr.js";
+import type { TransactionSource } from "./transaction_source.js";
+import { Transaction } from "./transaction.js";
+import { FeeBumpTransaction } from "./fee_bump_transaction.js";
+import { Memo } from "./memo.js";
+import { Asset } from "./asset.js";
+import { Keypair } from "./keypair.js";
+/**
+ * Minimum base fee for transactions. If this fee is below the network
+ * minimum, the transaction will fail. The more operations in the
+ * transaction, the greater the required fee. Use
+ * {@link Gateway.Server.fetchBaseFee} to get an accurate value of minimum
+ * transaction fee on the network.
+ *
+ * @see [Fees](https://docs.digitalworld.global/docs/glossary/fees/)
+ */
+export declare const BASE_FEE = "100";
+/**
+ * @see {@link TransactionBuilder.setTimeout}
+ * @see [Timeout](https://docs.digitalworld.global/api/resources/transactions/post/)
+ */
+export declare const TimeoutInfinite = 0;
+/**
+ * Soroban fee parameters for resource-limited transactions.
+ */
+export interface SorobanFees {
+    /** The number of instructions executed by the transaction. */
+    instructions: number;
+    /** The number of bytes read from the ledger by the transaction. */
+    readBytes: number;
+    /** The number of bytes written to the ledger by the transaction. */
+    writeBytes: number;
+    /** The fee to be paid for the transaction, in Nats. */
+    resourceFee: bigint;
+}
+/**
+ * Options for constructing a {@link TransactionBuilder}.
+ */
+export interface TransactionBuilderOptions {
+    /** Max fee you're willing to pay per operation in this transaction (**in Nats**). */
+    fee: string;
+    /** Memo for the transaction. */
+    memo?: Memo;
+    /**
+     * Passphrase of the target Digital World network (e.g. "Digital World
+     * Network ; June 2021" for the pubnet).
+     */
+    networkPassphrase?: string;
+    /** Timebounds for the validity of this transaction. */
+    timebounds?: {
+        /** 64-bit UNIX timestamp or Date object. */
+        minTime?: Date | number | string;
+        /** 64-bit UNIX timestamp or Date object. */
+        maxTime?: Date | number | string;
+    };
+    /** Ledger bounds for the validity of this transaction. */
+    ledgerbounds?: {
+        /** Number of the minimum ledger sequence. */
+        minLedger?: number;
+        /** Number of the maximum ledger sequence. */
+        maxLedger?: number;
+    };
+    /** Minimum source account sequence number this transaction is valid for. */
+    minAccountSequence?: string;
+    /** Minimum seconds between source account sequence time and ledger time. */
+    minAccountSequenceAge?: bigint;
+    /** Minimum ledgers between source account sequence and current ledger. */
+    minAccountSequenceLedgerGap?: number;
+    /** List of extra signers required for this transaction. */
+    extraSigners?: string[];
+    /**
+     * An instance of {@link xdr.SorobanTransactionData} or a base64 string.
+     * Provides resource estimations for Soroban transactions. Has no effect on
+     * non-contract transactions.
+     */
+    sorobanData?: xdr.SorobanTransactionData | string;
+}
+/**
+ * <p>Transaction builder helps constructs a new `{@link Transaction}` using the
+ * given {@link Account} as the transaction's "source account". The transaction
+ * will use the current sequence number of the given account as its sequence
+ * number and increment the given account's sequence number by one. The given
+ * source account must include a private key for signing the transaction or an
+ * error will be thrown.</p>
+ *
+ * <p>Operations can be added to the transaction via their corresponding builder
+ * methods, and each returns the TransactionBuilder object so they can be
+ * chained together. After adding the desired operations, call the `build()`
+ * method on the `TransactionBuilder` to return a fully constructed
+ * {@link Transaction} that can be signed. The returned transaction will contain the
+ * sequence number of the source account and include the signature from the
+ * source account.</p>
+ *
+ * <p><strong>Be careful about unsubmitted transactions!</strong> When you build
+ * a transaction, `digital-world-sdk` automatically increments the source account's
+ * sequence number. If you end up not submitting this transaction and submitting
+ * another one instead, it'll fail due to the sequence number being wrong. So if
+ * you decide not to use a built transaction, make sure to update the source
+ * account's sequence number with
+ * [Server.loadAccount](https://digitalworld.github.io/digital-world-js-sdk/Server.html#loadAccount)
+ * before creating another transaction.</p>
+ *
+ * <p>The following code example creates a new transaction with {@link
+ * Operation.createAccount} and {@link Operation.payment} operations. The
+ * Transaction's source account first funds `destinationA`, then sends a payment
+ * to `destinationB`. The built transaction is then signed by
+ * `sourceKeypair`.</p>
+ *
+ * ```
+ * var transaction = new TransactionBuilder(source, { fee, networkPassphrase: Networks.TESTNET })
+ * .addOperation(Operation.createAccount({
+ *     destination: destinationA,
+ *     startingBalance: "20"
+ * })) // <- funds and creates destinationA
+ * .addOperation(Operation.payment({
+ *     destination: destinationB,
+ *     amount: "100",
+ *     asset: Asset.native()
+ * })) // <- sends 100 NATIVE to destinationB
+ * .setTimeout(30)
+ * .build();
+ *
+ * transaction.sign(sourceKeypair);
+ * ```
+ *
+ */
+export declare class TransactionBuilder {
+    source: TransactionSource;
+    operations: xdr.Operation[];
+    baseFee: string;
+    timebounds: {
+        minTime?: Date | number | string;
+        maxTime?: Date | number | string;
+    } | null;
+    ledgerbounds: {
+        minLedger?: number;
+        maxLedger?: number;
+    } | null;
+    minAccountSequence: string | null;
+    minAccountSequenceAge: bigint | null;
+    minAccountSequenceLedgerGap: number | null;
+    extraSigners: string[] | null;
+    memo: Memo;
+    networkPassphrase: string | null;
+    sorobanData: xdr.SorobanTransactionData | null;
+    /**
+     * @param sourceAccount - source account for this transaction
+     * @param opts - options object (see {@link TransactionBuilderOptions})
+     */
+    constructor(sourceAccount: TransactionSource, opts?: TransactionBuilderOptions);
+    /**
+     * 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: Transaction, opts?: Partial<TransactionBuilderOptions>): TransactionBuilder;
+    /**
+     * Adds an operation to the transaction.
+     *
+     * @param operation - The xdr operation object, use {@link
+     *     Operation} static methods.
+     */
+    addOperation(operation: xdr.Operation): TransactionBuilder;
+    /**
+     * 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: xdr.Operation, index: number): TransactionBuilder;
+    /**
+     * Removes the operations from the builder (useful when cloning).
+     */
+    clearOperations(): TransactionBuilder;
+    /**
+     * Removes the operation at the specified index from the transaction.
+     *
+     * @param index - The index of the operation to remove.
+     */
+    clearOperationAt(index: number): TransactionBuilder;
+    /**
+     * Adds a memo to the transaction.
+     * @param memo - {@link Memo} object
+     */
+    addMemo(memo: Memo): TransactionBuilder;
+    /**
+     * 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: number): TransactionBuilder;
+    /**
+     * 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: Date | number, maxEpochOrDate: Date | number): TransactionBuilder;
+    /**
+     * 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: number, maxLedger: number): TransactionBuilder;
+    /**
+     * 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: string): TransactionBuilder;
+    /**
+     * 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: bigint): TransactionBuilder;
+    /**
+     * 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: number): TransactionBuilder;
+    /**
+     * 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: string[]): TransactionBuilder;
+    /**
+     * 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: string): TransactionBuilder;
+    /**
+     * 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: xdr.SorobanTransactionData | string): TransactionBuilder;
+    /**
+     * 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: string, asset: Asset, amount: bigint | string, sorobanFees?: SorobanFees): TransactionBuilder;
+    /**
+     * Builds the transaction and increments the source account's sequence
+     * number by 1.
+     */
+    build(): Transaction;
+    /**
+     * Checks whether any v2 preconditions have been set on this builder.
+     */
+    hasV2Preconditions(): boolean;
+    /**
+     * 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: Keypair | string, baseFee: string, innerTx: Transaction, networkPassphrase: string): FeeBumpTransaction;
+    /**
+     * 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: xdr.TransactionEnvelope | string, networkPassphrase: string): FeeBumpTransaction | Transaction;
+}
+/**
+ * Checks whether a provided object is a valid Date.
+ * @param d - date object
+ */
+export declare function isValidDate(d: Date | number | string): d is Date;