@hiero-ledger/sdk 2.70.0

package/lib/transaction/BatchTransaction.d.ts

@@ -0,0 +1,134 @@
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.ITransaction} HieroProto.proto.ITransaction
+ * @typedef {import("@hashgraph/proto").proto.ITransactionBody} HieroProto.proto.ITransactionBody
+ * @typedef {import("@hashgraph/proto").proto.TransactionBody} HieroProto.proto.TransactionBody
+ * @typedef {import("@hashgraph/proto").proto.ITransactionResponse} HieroProto.proto.ITransactionResponse
+ */
+/**
+ * @typedef {import("../channel/Channel.js").default} Channel
+ * @typedef {import("../transaction/TransactionId.js").default} TransactionId
+ * @typedef {import("../account/AccountId.js").default} AccountId
+ * @typedef {import("../Key.js").default} Key
+ */
+/**
+ * @description Execute multiple transactions in a single consensus event. This allows for atomic execution of multiple
+ * transactions, where they either all succeed or all fail together.
+ * <p>
+ * Requirements:
+ * <ul>
+ *     <li>All inner transactions must be frozen before being added to the batch</li>
+ *     <li>All inner transactions must have a batch key set</li>
+ *     <li>All inner transactions must be signed as required for each individual transaction</li>
+ *     <li>The BatchTransaction must be signed by all batch keys of the inner transactions</li>
+ *     <li>Certain transaction types (FreezeTransaction, BatchTransaction) are not allowed in a batch</li>
+ * </ul>
+ * <p>
+ * Important notes:
+ * <ul>
+ *     <li>Fees are assessed for each inner transaction separately</li>
+ *     <li>The maximum number of inner transactions in a batch is limited to 25</li>
+ *     <li>Inner transactions cannot be scheduled transactions</li>
+ * </ul>
+ *
+ */
+export default class BatchTransaction extends Transaction {
+    /**
+     * @internal
+     * @param {proto.ITransaction[]} transactions
+     * @param {proto.ISignedTransaction[]} signedTransactions
+     * @param {TransactionId[]} transactionIds
+     * @param {AccountId[]} nodeIds
+     * @param {HieroProto.proto.ITransactionBody[]} bodies
+     * @returns {BatchTransaction}
+     */
+    static _fromProtobuf(transactions: proto.ITransaction[], signedTransactions: proto.ISignedTransaction[], transactionIds: TransactionId[], nodeIds: AccountId[], bodies: HieroProto.proto.ITransactionBody[]): BatchTransaction;
+    /**
+     * @param {object} [options]
+     * @param {Transaction[] | null} [options.transactions]
+     */
+    constructor(options?: {
+        transactions?: Transaction[] | null | undefined;
+    });
+    _batchTransactions: Transaction[];
+    /**
+     * Set the list of transactions to be executed as part of this BatchTransaction.
+     * <p>
+     * Requirements for each inner transaction:
+     * <ul>
+     *     <li>Must be frozen (use {@link Transaction#freeze()} or {@link Transaction#freezeWith(Client)})</li>
+     *     <li>Must have a batch key set (use {@link Transaction#setBatchKey(Key)}} or {@link Transaction#batchify(Client, Key)})</li>
+     *     <li>Must not be a blacklisted transaction type</li>
+     * </ul>
+     * <p>
+     * Note: This method creates a defensive copy of the provided list.
+     *
+     * @param {Transaction[]} txs
+     * @returns {BatchTransaction}
+     */
+    setInnerTransactions(txs: Transaction[]): BatchTransaction;
+    /**
+     * Append a transaction to the list of transactions this BatchTransaction will execute.
+     * <p>
+     * Requirements for the inner transaction:
+     * <ul>
+     *     <li>Must be frozen (use {@link Transaction#freeze()} or {@link Transaction#freezeWith(Client)})</li>
+     *     <li>Must have a batch key set (use {@link Transaction#setBatchKey(Key)}} or {@link Transaction#batchify(Client, Key)})</li>
+     *     <li>Must not be a blacklisted transaction type</li>
+     * </ul>
+     *
+     * @param {Transaction} tx
+     * @returns {BatchTransaction}
+     */
+    addInnerTransaction(tx: Transaction): BatchTransaction;
+    /**
+     * Get the list of transactions this BatchTransaction is currently configured to execute.
+     * <p>
+     * Note: This returns the actual list of transactions. Modifications to this list will affect
+     * the batch transaction if it is not frozen.
+     *
+     * @returns {Transaction[]}
+     */
+    get innerTransactions(): Transaction[];
+    /**
+     * Get the list of transaction IDs of each inner transaction of this BatchTransaction.
+     * <p>
+     * This method is particularly useful after execution to:
+     * <ul>
+     *     <li>Track individual transaction results</li>
+     *     <li>Query receipts for specific inner transactions</li>
+     *     <li>Monitor the status of each transaction in the batch</li>
+     * </ul>
+     * <p>
+     * <b>NOTE:</b> Transaction IDs will only be meaningful after the batch transaction has been
+     * executed or the IDs have been explicitly set on the inner transactions.
+     *
+     * @returns {(TransactionId | null)[]}
+     */
+    get innerTransactionIds(): (TransactionId | null)[];
+    /**
+     *
+     * @returns {proto.AtomicBatchTransactionBody}
+     */
+    _makeTransactionData(): proto.AtomicBatchTransactionBody;
+    /**
+     * @description Validate the transaction
+     * @param {Transaction} tx
+     * @throws {Error} If the transaction is a batch or freeze transaction
+     */
+    _validateTransaction(tx: Transaction): void;
+}
+export namespace HieroProto {
+    namespace proto {
+        type ITransaction = import("@hashgraph/proto").proto.ITransaction;
+        type ITransactionBody = import("@hashgraph/proto").proto.ITransactionBody;
+        type TransactionBody = import("@hashgraph/proto").proto.TransactionBody;
+        type ITransactionResponse = import("@hashgraph/proto").proto.ITransactionResponse;
+    }
+}
+export type Channel = import("../channel/Channel.js").default;
+export type TransactionId = import("../transaction/TransactionId.js").default;
+export type AccountId = import("../account/AccountId.js").default;
+export type Key = import("../Key.js").default;
+import Transaction from "./Transaction.js";
+import { proto } from "@hashgraph/proto";

package/lib/transaction/BatchTransaction.js

@@ -0,0 +1,2 @@
+import t from"../system/FreezeTransaction.js";import a,{TRANSACTION_REGISTRY as r}from"./Transaction.js";import{proto as n}from"@hashgraph/proto";class o extends a{constructor(t){super(),this._batchTransactions=t?.transactions||[]}setInnerTransactions(t){return t.forEach((t=>this._validateTransaction(t))),this._batchTransactions=t,this}addInnerTransaction(t){return this._validateTransaction(t),this._requireNotFrozen(),this._batchTransactions.push(t),this}get innerTransactions(){return this._batchTransactions}get innerTransactionIds(){return Array.isArray(this._batchTransactions)?this._batchTransactions.map((t=>t.transactionId)):[]}_makeTransactionData(){if(!Array.isArray(this._batchTransactions))return{transactions:[]};return{transactions:this._batchTransactions.map((t=>n.SignedTransaction.encode(t._signedTransactions.get(0)).finish()))}}static _fromProtobuf(t,s,i,e,c){const h=c[0],d=h.atomicBatch?.transactions,T=d?.map((t=>n.SignedTransaction.decode(t))),u=T?.map((t=>{const a=n.TransactionBody.decode(t.bodyBytes),o=a.data;if(!o)throw new Error("Transaction type not found");const s=r.get(o);if(!s)throw new Error("fromProtobuf not found");return s([],[t],[],[],[a])}));return a._fromProtobufTransactions(new o({transactions:u}),t,s,i,e,c)}_getTransactionDataCase(){return"atomicBatch"}_getLogId(){return`AtomicBatch:${this._transactionIds.current.validStart.toString()}`}_execute(t,a){return t.util.atomicBatch(a)}_validateTransaction(a){if(a instanceof o||a instanceof t)throw new Error("Transaction is not allowed to be added to a batch");if(!a.isFrozen())throw new Error("Transaction must be frozen before being added to a batch");if(!a.batchKey)throw new Error("Transaction must have a batch key")}}r.set("atomicBatch",o._fromProtobuf);export{o as default};
+//# sourceMappingURL=BatchTransaction.js.map

package/lib/transaction/BatchTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchTransaction.js","sources":["../../src/transaction/BatchTransaction.js"],"sourcesContent":["import FreezeTransaction from \"../system/FreezeTransaction.js\";\nimport Transaction, { TRANSACTION_REGISTRY } from \"./Transaction.js\";\nimport { proto } from \"@hashgraph/proto\";\n\n/**\n * @namespace proto\n * @typedef {import(\"@hashgraph/proto\").proto.ITransaction} HieroProto.proto.ITransaction\n * @typedef {import(\"@hashgraph/proto\").proto.ITransactionBody} HieroProto.proto.ITransactionBody\n * @typedef {import(\"@hashgraph/proto\").proto.TransactionBody} HieroProto.proto.TransactionBody\n * @typedef {import(\"@hashgraph/proto\").proto.ITransactionResponse} HieroProto.proto.ITransactionResponse\n */\n\n/**\n * @typedef {import(\"../channel/Channel.js\").default} Channel\n * @typedef {import(\"../transaction/TransactionId.js\").default} TransactionId\n * @typedef {import(\"../account/AccountId.js\").default} AccountId\n * @typedef {import(\"../Key.js\").default} Key\n */\n\n/**\n * @description Execute multiple transactions in a single consensus event. This allows for atomic execution of multiple\n * transactions, where they either all succeed or all fail together.\n * <p>\n * Requirements:\n * <ul>\n *     <li>All inner transactions must be frozen before being added to the batch</li>\n *     <li>All inner transactions must have a batch key set</li>\n *     <li>All inner transactions must be signed as required for each individual transaction</li>\n *     <li>The BatchTransaction must be signed by all batch keys of the inner transactions</li>\n *     <li>Certain transaction types (FreezeTransaction, BatchTransaction) are not allowed in a batch</li>\n * </ul>\n * <p>\n * Important notes:\n * <ul>\n *     <li>Fees are assessed for each inner transaction separately</li>\n *     <li>The maximum number of inner transactions in a batch is limited to 25</li>\n *     <li>Inner transactions cannot be scheduled transactions</li>\n * </ul>\n *\n */\nexport default class BatchTransaction extends Transaction {\n    /**\n     * @param {object} [options]\n     * @param {Transaction[] | null} [options.transactions]\n     */\n    constructor(options) {\n        super();\n        this._batchTransactions = options?.transactions || [];\n    }\n\n    /**\n     * Set the list of transactions to be executed as part of this BatchTransaction.\n     * <p>\n     * Requirements for each inner transaction:\n     * <ul>\n     *     <li>Must be frozen (use {@link Transaction#freeze()} or {@link Transaction#freezeWith(Client)})</li>\n     *     <li>Must have a batch key set (use {@link Transaction#setBatchKey(Key)}} or {@link Transaction#batchify(Client, Key)})</li>\n     *     <li>Must not be a blacklisted transaction type</li>\n     * </ul>\n     * <p>\n     * Note: This method creates a defensive copy of the provided list.\n     *\n     * @param {Transaction[]} txs\n     * @returns {BatchTransaction}\n     */\n    setInnerTransactions(txs) {\n        txs.forEach((tx) => this._validateTransaction(tx));\n        this._batchTransactions = txs;\n        return this;\n    }\n\n    /**\n     * Append a transaction to the list of transactions this BatchTransaction will execute.\n     * <p>\n     * Requirements for the inner transaction:\n     * <ul>\n     *     <li>Must be frozen (use {@link Transaction#freeze()} or {@link Transaction#freezeWith(Client)})</li>\n     *     <li>Must have a batch key set (use {@link Transaction#setBatchKey(Key)}} or {@link Transaction#batchify(Client, Key)})</li>\n     *     <li>Must not be a blacklisted transaction type</li>\n     * </ul>\n     *\n     * @param {Transaction} tx\n     * @returns {BatchTransaction}\n     */\n    addInnerTransaction(tx) {\n        this._validateTransaction(tx);\n        this._requireNotFrozen();\n        this._batchTransactions.push(tx);\n        return this;\n    }\n\n    /**\n     * Get the list of transactions this BatchTransaction is currently configured to execute.\n     * <p>\n     * Note: This returns the actual list of transactions. Modifications to this list will affect\n     * the batch transaction if it is not frozen.\n     *\n     * @returns {Transaction[]}\n     */\n    get innerTransactions() {\n        return this._batchTransactions;\n    }\n\n    /**\n     * Get the list of transaction IDs of each inner transaction of this BatchTransaction.\n     * <p>\n     * This method is particularly useful after execution to:\n     * <ul>\n     *     <li>Track individual transaction results</li>\n     *     <li>Query receipts for specific inner transactions</li>\n     *     <li>Monitor the status of each transaction in the batch</li>\n     * </ul>\n     * <p>\n     * <b>NOTE:</b> Transaction IDs will only be meaningful after the batch transaction has been\n     * executed or the IDs have been explicitly set on the inner transactions.\n     *\n     * @returns {(TransactionId | null)[]}\n     */\n    get innerTransactionIds() {\n        if (!Array.isArray(this._batchTransactions)) {\n            return [];\n        }\n\n        return this._batchTransactions.map((tx) => tx.transactionId);\n    }\n\n    /**\n     *\n     * @returns {proto.AtomicBatchTransactionBody}\n     */\n    _makeTransactionData() {\n        if (!Array.isArray(this._batchTransactions)) {\n            return {\n                transactions: [],\n            };\n        }\n\n        const signedTransactionBytes = this._batchTransactions.map((tx) =>\n            proto.SignedTransaction.encode(\n                tx._signedTransactions.get(0),\n            ).finish(),\n        );\n        return {\n            transactions: signedTransactionBytes,\n        };\n    }\n\n    /**\n     * @internal\n     * @param {proto.ITransaction[]} transactions\n     * @param {proto.ISignedTransaction[]} signedTransactions\n     * @param {TransactionId[]} transactionIds\n     * @param {AccountId[]} nodeIds\n     * @param {HieroProto.proto.ITransactionBody[]} bodies\n     * @returns {BatchTransaction}\n     */\n    static _fromProtobuf(\n        transactions,\n        signedTransactions,\n        transactionIds,\n        nodeIds,\n        bodies,\n    ) {\n        const body = bodies[0];\n        const atomicBatchTxBytes = body.atomicBatch?.transactions;\n\n        const atomicBatchSignedTransactions = atomicBatchTxBytes?.map((tx) =>\n            proto.SignedTransaction.decode(tx),\n        );\n\n        const atomicBatchTxs = atomicBatchSignedTransactions?.map((tx) => {\n            const txBody = proto.TransactionBody.decode(tx.bodyBytes);\n            const txType = txBody.data;\n            if (!txType) {\n                throw new Error(\"Transaction type not found\");\n            }\n\n            const fromProtobuf = TRANSACTION_REGISTRY.get(txType);\n            if (!fromProtobuf) {\n                throw new Error(\"fromProtobuf not found\");\n            }\n            /* Inner transactions only have one signed transactios therefore\n            the other properties are empty that are needed from the \n            Transaction._fromProtobufTransactions method\n            */\n\n            /**\n             * @type {proto.ITransaction[]}\n             */\n            const innerTransactions = [];\n            /**\n             * @type {proto.ISignedTransaction[]}\n             */\n            const signedInnerTransactions = [tx];\n            /**\n             * @type {TransactionId[]}\n             */\n            const innerTransactionIds = [];\n\n            /**\n             * Node account IDs is empty for inner transactions\n             * @type {AccountId[]}\n             */\n            const nodeAccountIds = [];\n\n            /**\n             * @type {HieroProto.proto.TransactionBody[]}\n             */\n            const bodies = [txBody];\n\n            return fromProtobuf(\n                innerTransactions,\n                signedInnerTransactions,\n                innerTransactionIds,\n                nodeAccountIds,\n                bodies,\n            );\n        });\n\n        return Transaction._fromProtobufTransactions(\n            new BatchTransaction({\n                transactions: atomicBatchTxs,\n            }),\n            transactions,\n            signedTransactions,\n            transactionIds,\n            nodeIds,\n            bodies,\n        );\n    }\n\n    /**\n     * This method returns a key for the `data` field in a transaction body.\n     * Each transaction overwrite this to make sure when we build the transaction body\n     * we set the right data field.\n     *\n     * @abstract\n     * @protected\n     * @returns {NonNullable<HieroProto.proto.TransactionBody[\"data\"]>}\n     */\n    _getTransactionDataCase() {\n        return \"atomicBatch\";\n    }\n\n    /**\n     * @description Get the log ID for the BatchTransaction.\n     * @returns {string}\n     */\n    _getLogId() {\n        const timestamp = /** @type {import(\"../Timestamp.js\").default} */ (\n            this._transactionIds.current.validStart\n        );\n        return `AtomicBatch:${timestamp.toString()}`;\n    }\n\n    /**\n     * @override\n     * @internal\n     * @param {Channel} channel\n     * @param {HieroProto.proto.ITransaction} request\n     * @returns {Promise<HieroProto.proto.ITransactionResponse>}\n     */\n    _execute(channel, request) {\n        return channel.util.atomicBatch(request);\n    }\n\n    /**\n     * @description Validate the transaction\n     * @param {Transaction} tx\n     * @throws {Error} If the transaction is a batch or freeze transaction\n     */\n    _validateTransaction(tx) {\n        if (tx instanceof BatchTransaction || tx instanceof FreezeTransaction) {\n            throw new Error(\n                \"Transaction is not allowed to be added to a batch\",\n            );\n        }\n        if (!tx.isFrozen()) {\n            throw new Error(\n                \"Transaction must be frozen before being added to a batch\",\n            );\n        }\n        if (!tx.batchKey) {\n            throw new Error(\"Transaction must have a batch key\");\n        }\n    }\n}\n\nTRANSACTION_REGISTRY.set(\n    \"atomicBatch\",\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    BatchTransaction._fromProtobuf,\n);\n"],"names":["BatchTransaction","Transaction","constructor","options","super","this","_batchTransactions","transactions","setInnerTransactions","txs","forEach","tx","_validateTransaction","addInnerTransaction","_requireNotFrozen","push","innerTransactions","innerTransactionIds","Array","isArray","map","transactionId","_makeTransactionData","proto","SignedTransaction","encode","_signedTransactions","get","finish","_fromProtobuf","signedTransactions","transactionIds","nodeIds","bodies","body","atomicBatchTxBytes","atomicBatch","atomicBatchSignedTransactions","decode","atomicBatchTxs","txBody","TransactionBody","bodyBytes","txType","data","Error","fromProtobuf","TRANSACTION_REGISTRY","_fromProtobufTransactions","_getTransactionDataCase","_getLogId","_transactionIds","current","toString","_execute","channel","request","util","FreezeTransaction","isFrozen","batchKey","set"],"mappings":"kJAwCe,MAAMA,UAAyBC,EAK1C,WAAAC,CAAYC,GACRC,QACAC,KAAKC,mBAAqBH,GAASI,cAAgB,EAC3D,CAiBI,oBAAAC,CAAqBC,GAGjB,OAFAA,EAAIC,SAASC,GAAON,KAAKO,qBAAqBD,KAC9CN,KAAKC,mBAAqBG,EACnBJ,IACf,CAeI,mBAAAQ,CAAoBF,GAIhB,OAHAN,KAAKO,qBAAqBD,GAC1BN,KAAKS,oBACLT,KAAKC,mBAAmBS,KAAKJ,GACtBN,IACf,CAUI,qBAAIW,GACA,OAAOX,KAAKC,kBACpB,CAiBI,uBAAIW,GACA,OAAKC,MAAMC,QAAQd,KAAKC,oBAIjBD,KAAKC,mBAAmBc,KAAKT,GAAOA,EAAGU,gBAHnC,EAInB,CAMI,oBAAAC,GACI,IAAKJ,MAAMC,QAAQd,KAAKC,oBACpB,MAAO,CACHC,aAAc,IAStB,MAAO,CACHA,aAN2BF,KAAKC,mBAAmBc,KAAKT,GACxDY,EAAMC,kBAAkBC,OACpBd,EAAGe,oBAAoBC,IAAI,IAC7BC,WAKd,CAWI,oBAAOC,CACHtB,EACAuB,EACAC,EACAC,EACAC,GAEA,MAAMC,EAAOD,EAAO,GACdE,EAAqBD,EAAKE,aAAa7B,aAEvC8B,EAAgCF,GAAoBf,KAAKT,GAC3DY,EAAMC,kBAAkBc,OAAO3B,KAG7B4B,EAAiBF,GAA+BjB,KAAKT,IACvD,MAAM6B,EAASjB,EAAMkB,gBAAgBH,OAAO3B,EAAG+B,WACzCC,EAASH,EAAOI,KACtB,IAAKD,EACD,MAAM,IAAIE,MAAM,8BAGpB,MAAMC,EAAeC,EAAqBpB,IAAIgB,GAC9C,IAAKG,EACD,MAAM,IAAID,MAAM,0BA+BpB,OAAOC,EArBmB,GAIM,CAACnC,GAIL,GAML,GAKR,CAAC6B,GAQf,IAGL,OAAOvC,EAAY+C,0BACf,IAAIhD,EAAiB,CACjBO,aAAcgC,IAElBhC,EACAuB,EACAC,EACAC,EACAC,EAEZ,CAWI,uBAAAgB,GACI,MAAO,aACf,CAMI,SAAAC,GAII,MAAO,eAFH7C,KAAK8C,gBAAgBC,QACxB,WAC+BC,YACxC,CASI,QAAAC,CAASC,EAASC,GACd,OAAOD,EAAQE,KAAKrB,YAAYoB,EACxC,CAOI,oBAAA5C,CAAqBD,GACjB,GAAIA,aAAcX,GAAoBW,aAAc+C,EAChD,MAAM,IAAIb,MACN,qDAGR,IAAKlC,EAAGgD,WACJ,MAAM,IAAId,MACN,4DAGR,IAAKlC,EAAGiD,SACJ,MAAM,IAAIf,MAAM,oCAE5B,EAGAE,EAAqBc,IACjB,cAEA7D,EAAiB6B"}

package/lib/transaction/CustomFeeLimit.cjs

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _AccountId = _interopRequireDefault(require("../account/AccountId.cjs"));
+var _CustomFixedFee = _interopRequireDefault(require("../token/CustomFixedFee.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.IFixedFee} HieroProto.proto.IFixedFee
+ * @typedef {import("@hashgraph/proto").proto.ICustomFeeLimit} HieroProto.proto.ICustomFeeLimit
+ */
+
+class CustomFeeLimit {
+  /**
+   *
+   * @param {object} props
+   * @param {?AccountId | string} [props.accountId]
+   * @param {?CustomFixedFee[]} [props.fees]
+   */
+  constructor(props = {}) {
+    /**
+     * @type {?AccountId}
+     */
+    this._accountId = null;
+    if (props.accountId) {
+      this.setAccountId(props.accountId);
+    }
+
+    /**
+     * @type {?CustomFixedFee[]}
+     */
+    this._fees = null;
+    if (props.fees) {
+      this.setFees(props.fees);
+    }
+  }
+
+  /**
+   * @static
+   * @param {HieroProto.proto.ICustomFeeLimit} customFeeLimit
+   * @returns {CustomFeeLimit}
+   */
+  static _fromProtobuf(customFeeLimit) {
+    return new CustomFeeLimit({
+      accountId: customFeeLimit.accountId != null ? _AccountId.default._fromProtobuf(customFeeLimit.accountId) : null,
+      fees: customFeeLimit.fees != null ? customFeeLimit.fees.map(fixedFee => {
+        return _CustomFixedFee.default._fromProtobuf({
+          fixedFee: fixedFee
+        });
+      }) : null
+    });
+  }
+
+  /**
+   * @returns {?AccountId}
+   */
+  getAccountId() {
+    return this._accountId;
+  }
+
+  /**
+   *
+   * @param {AccountId | string} accountId
+   * @returns {this}
+   */
+  setAccountId(accountId) {
+    if (accountId instanceof _AccountId.default) {
+      this._accountId = accountId;
+    } else {
+      this._accountId = _AccountId.default.fromString(accountId);
+    }
+    return this;
+  }
+
+  /**
+   * @returns {?CustomFixedFee[]}
+   */
+  getFees() {
+    return this._fees;
+  }
+
+  /**
+   *
+   * @param {CustomFixedFee[]} fees
+   * @returns {this}
+   */
+  setFees(fees) {
+    this._fees = fees;
+    return this;
+  }
+
+  /**
+   *
+   * @returns {HieroProto.proto.ICustomFeeLimit}
+   */
+  _toProtobuf() {
+    /** @type {HieroProto.proto.IFixedFee[]} */
+    const protoFixedFees = [];
+    if (this._fees != null) {
+      this._fees.forEach(fixedFee => {
+        const fixedFeeProto = fixedFee._toProtobuf();
+        if (fixedFeeProto.fixedFee != null) {
+          protoFixedFees.push(fixedFeeProto.fixedFee);
+        }
+      });
+    }
+    return {
+      accountId: this._accountId != null ? this._accountId._toProtobuf() : null,
+      fees: protoFixedFees
+    };
+  }
+}
+exports.default = CustomFeeLimit;

package/lib/transaction/CustomFeeLimit.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @namespace proto
+ * @typedef {import("@hashgraph/proto").proto.IFixedFee} HieroProto.proto.IFixedFee
+ * @typedef {import("@hashgraph/proto").proto.ICustomFeeLimit} HieroProto.proto.ICustomFeeLimit
+ */
+export default class CustomFeeLimit {
+    /**
+     * @static
+     * @param {HieroProto.proto.ICustomFeeLimit} customFeeLimit
+     * @returns {CustomFeeLimit}
+     */
+    static _fromProtobuf(customFeeLimit: HieroProto.proto.ICustomFeeLimit): CustomFeeLimit;
+    /**
+     *
+     * @param {object} props
+     * @param {?AccountId | string} [props.accountId]
+     * @param {?CustomFixedFee[]} [props.fees]
+     */
+    constructor(props?: {
+        accountId?: string | AccountId | null | undefined;
+        fees?: CustomFixedFee[] | null | undefined;
+    });
+    /**
+     * @type {?AccountId}
+     */
+    _accountId: AccountId | null;
+    /**
+     * @type {?CustomFixedFee[]}
+     */
+    _fees: CustomFixedFee[] | null;
+    /**
+     * @returns {?AccountId}
+     */
+    getAccountId(): AccountId | null;
+    /**
+     *
+     * @param {AccountId | string} accountId
+     * @returns {this}
+     */
+    setAccountId(accountId: AccountId | string): this;
+    /**
+     * @returns {?CustomFixedFee[]}
+     */
+    getFees(): CustomFixedFee[] | null;
+    /**
+     *
+     * @param {CustomFixedFee[]} fees
+     * @returns {this}
+     */
+    setFees(fees: CustomFixedFee[]): this;
+    /**
+     *
+     * @returns {HieroProto.proto.ICustomFeeLimit}
+     */
+    _toProtobuf(): HieroProto.proto.ICustomFeeLimit;
+}
+export namespace HieroProto {
+    namespace proto {
+        type IFixedFee = import("@hashgraph/proto").proto.IFixedFee;
+        type ICustomFeeLimit = import("@hashgraph/proto").proto.ICustomFeeLimit;
+    }
+}
+import AccountId from "../account/AccountId.js";
+import CustomFixedFee from "../token/CustomFixedFee.js";

package/lib/transaction/CustomFeeLimit.js

@@ -0,0 +1,2 @@
+import t from"../account/AccountId.js";import e from"../token/CustomFixedFee.js";class o{constructor(t={}){this._accountId=null,t.accountId&&this.setAccountId(t.accountId),this._fees=null,t.fees&&this.setFees(t.fees)}static _fromProtobuf(s){return new o({accountId:null!=s.accountId?t._fromProtobuf(s.accountId):null,fees:null!=s.fees?s.fees.map((t=>e._fromProtobuf({fixedFee:t}))):null})}getAccountId(){return this._accountId}setAccountId(e){return this._accountId=e instanceof t?e:t.fromString(e),this}getFees(){return this._fees}setFees(t){return this._fees=t,this}_toProtobuf(){const t=[];return null!=this._fees&&this._fees.forEach((e=>{const o=e._toProtobuf();null!=o.fixedFee&&t.push(o.fixedFee)})),{accountId:null!=this._accountId?this._accountId._toProtobuf():null,fees:t}}}export{o as default};
+//# sourceMappingURL=CustomFeeLimit.js.map

package/lib/transaction/CustomFeeLimit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomFeeLimit.js","sources":["../../src/transaction/CustomFeeLimit.js"],"sourcesContent":["import AccountId from \"../account/AccountId.js\";\nimport CustomFixedFee from \"../token/CustomFixedFee.js\";\n\n/**\n * @namespace proto\n * @typedef {import(\"@hashgraph/proto\").proto.IFixedFee} HieroProto.proto.IFixedFee\n * @typedef {import(\"@hashgraph/proto\").proto.ICustomFeeLimit} HieroProto.proto.ICustomFeeLimit\n */\n\nexport default class CustomFeeLimit {\n    /**\n     *\n     * @param {object} props\n     * @param {?AccountId | string} [props.accountId]\n     * @param {?CustomFixedFee[]} [props.fees]\n     */\n    constructor(props = {}) {\n        /**\n         * @type {?AccountId}\n         */\n        this._accountId = null;\n\n        if (props.accountId) {\n            this.setAccountId(props.accountId);\n        }\n\n        /**\n         * @type {?CustomFixedFee[]}\n         */\n        this._fees = null;\n\n        if (props.fees) {\n            this.setFees(props.fees);\n        }\n    }\n\n    /**\n     * @static\n     * @param {HieroProto.proto.ICustomFeeLimit} customFeeLimit\n     * @returns {CustomFeeLimit}\n     */\n    static _fromProtobuf(customFeeLimit) {\n        return new CustomFeeLimit({\n            accountId:\n                customFeeLimit.accountId != null\n                    ? AccountId._fromProtobuf(customFeeLimit.accountId)\n                    : null,\n            fees:\n                customFeeLimit.fees != null\n                    ? customFeeLimit.fees.map((fixedFee) => {\n                          return CustomFixedFee._fromProtobuf({\n                              fixedFee: fixedFee,\n                          });\n                      })\n                    : null,\n        });\n    }\n\n    /**\n     * @returns {?AccountId}\n     */\n    getAccountId() {\n        return this._accountId;\n    }\n\n    /**\n     *\n     * @param {AccountId | string} accountId\n     * @returns {this}\n     */\n    setAccountId(accountId) {\n        if (accountId instanceof AccountId) {\n            this._accountId = accountId;\n        } else {\n            this._accountId = AccountId.fromString(accountId);\n        }\n        return this;\n    }\n\n    /**\n     * @returns {?CustomFixedFee[]}\n     */\n    getFees() {\n        return this._fees;\n    }\n\n    /**\n     *\n     * @param {CustomFixedFee[]} fees\n     * @returns {this}\n     */\n    setFees(fees) {\n        this._fees = fees;\n\n        return this;\n    }\n\n    /**\n     *\n     * @returns {HieroProto.proto.ICustomFeeLimit}\n     */\n    _toProtobuf() {\n        /** @type {HieroProto.proto.IFixedFee[]} */\n        const protoFixedFees = [];\n\n        if (this._fees != null) {\n            this._fees.forEach((fixedFee) => {\n                const fixedFeeProto = fixedFee._toProtobuf();\n                if (fixedFeeProto.fixedFee != null) {\n                    protoFixedFees.push(fixedFeeProto.fixedFee);\n                }\n            });\n        }\n\n        return {\n            accountId:\n                this._accountId != null ? this._accountId._toProtobuf() : null,\n            fees: protoFixedFees,\n        };\n    }\n}\n"],"names":["CustomFeeLimit","constructor","props","this","_accountId","accountId","setAccountId","_fees","fees","setFees","_fromProtobuf","customFeeLimit","AccountId","map","fixedFee","CustomFixedFee","getAccountId","fromString","getFees","_toProtobuf","protoFixedFees","forEach","fixedFeeProto","push"],"mappings":"iFASe,MAAMA,EAOjB,WAAAC,CAAYC,EAAQ,IAIhBC,KAAKC,WAAa,KAEdF,EAAMG,WACNF,KAAKG,aAAaJ,EAAMG,WAM5BF,KAAKI,MAAQ,KAETL,EAAMM,MACNL,KAAKM,QAAQP,EAAMM,KAE/B,CAOI,oBAAOE,CAAcC,GACjB,OAAO,IAAIX,EAAe,CACtBK,UACgC,MAA5BM,EAAeN,UACTO,EAAUF,cAAcC,EAAeN,WACvC,KACVG,KAC2B,MAAvBG,EAAeH,KACTG,EAAeH,KAAKK,KAAKC,GACdC,EAAeL,cAAc,CAChCI,SAAUA,MAGlB,MAEtB,CAKI,YAAAE,GACI,OAAOb,KAAKC,UACpB,CAOI,YAAAE,CAAaD,GAMT,OAJIF,KAAKC,WADLC,aAAqBO,EACHP,EAEAO,EAAUK,WAAWZ,GAEpCF,IACf,CAKI,OAAAe,GACI,OAAOf,KAAKI,KACpB,CAOI,OAAAE,CAAQD,GAGJ,OAFAL,KAAKI,MAAQC,EAENL,IACf,CAMI,WAAAgB,GAEI,MAAMC,EAAiB,GAWvB,OATkB,MAAdjB,KAAKI,OACLJ,KAAKI,MAAMc,SAASP,IAChB,MAAMQ,EAAgBR,EAASK,cACD,MAA1BG,EAAcR,UACdM,EAAeG,KAAKD,EAAcR,SACtD,IAIe,CACHT,UACuB,MAAnBF,KAAKC,WAAqBD,KAAKC,WAAWe,cAAgB,KAC9DX,KAAMY,EAElB"}

package/lib/transaction/List.cjs

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * A custom list type which round robins, supports locking, and as additional
+ * QoL improvements.
+ *
+ * @template {any} T
+ */
+class List {
+  constructor() {
+    /** @type {T[]} */
+    this.list = [];
+    this.locked = false;
+    this.index = 0;
+  }
+
+  /**
+   * Overwrite the entire list.
+   *
+   * @throws if the list is locked
+   * @param {T[]} list
+   * @returns {this}
+   */
+  setList(list) {
+    if (this.locked) {
+      throw new Error("list is locked");
+    }
+    this.list = list;
+    this.index = 0;
+    return this;
+  }
+
+  /**
+   * Push items to the end of the list.
+   *
+   * @throws if the list is locked
+   * @param {T[]} items
+   * @returns {this}
+   */
+  push(...items) {
+    if (this.locked) {
+      throw new Error("list is locked");
+    }
+    this.list.push(...items);
+    return this;
+  }
+
+  /**
+   * Locks the list.
+   *
+   * @returns {this}
+   */
+  setLocked() {
+    this.locked = true;
+    return this;
+  }
+
+  /**
+   * Clear the list
+   */
+  clear() {
+    this.list = [];
+    this.index = 0;
+    this.locked = false;
+  }
+
+  /**
+   * The get value at a particular index.
+   *
+   * @param {number} index
+   * @returns {T}
+   */
+  get(index) {
+    return this.list[index];
+  }
+
+  /**
+   * Set value at index
+   *
+   * @param {number} index
+   * @param {T} item
+   * @returns {this}
+   */
+  set(index, item) {
+    // QoL: If the index is at the end simply push the element to the end
+    if (index === this.length) {
+      this.list.push(item);
+    } else {
+      this.list[index] = item;
+    }
+    return this;
+  }
+
+  /**
+   * Set value at index if it's not already set
+   *
+   * @throws if the list is locked
+   * @param {number} index
+   * @param {() => T} lambda
+   * @returns {this}
+   */
+  setIfAbsent(index, lambda) {
+    if (index == this.length || this.list[index] == null) {
+      this.set(index, lambda());
+    }
+    return this;
+  }
+
+  /**
+   * Get the current value, and advance the index
+   *
+   * @returns {T}
+   */
+  get next() {
+    return this.get(this.advance());
+  }
+
+  /**
+   * Get the current value.
+   *
+   * @returns {T}
+   */
+  get current() {
+    return this.get(this.index);
+  }
+
+  /**
+   * Advance the index to the next element in a round robin fashion
+   *
+   * @returns {number}
+   */
+  advance() {
+    const index = this.index;
+    this.index = (this.index + 1) % this.list.length;
+    return index;
+  }
+
+  /**
+   * Is the list empty
+   *
+   * @returns {boolean}
+   */
+  get isEmpty() {
+    return this.length === 0;
+  }
+
+  /**
+   * Get the length of the list
+   *
+   * @returns {number}
+   */
+  get length() {
+    return this.list.length;
+  }
+
+  /**
+   * Shallow clone this list.
+   * Perhaps we should explicitly call this `shallowClone()` since it doesn't
+   * clone the list inside?
+   *
+   * @returns {List<T>}
+   */
+  clone() {
+    /** @type {List<T>} */
+    const list = new List();
+    list.list = this.list;
+    list.locked = this.locked;
+    return list;
+  }
+}
+exports.default = List;

package/lib/transaction/List.d.ts

@@ -0,0 +1,100 @@
+/**
+ * A custom list type which round robins, supports locking, and as additional
+ * QoL improvements.
+ *
+ * @template {any} T
+ */
+export default class List<T extends unknown> {
+    /** @type {T[]} */
+    list: T[];
+    locked: boolean;
+    index: number;
+    /**
+     * Overwrite the entire list.
+     *
+     * @throws if the list is locked
+     * @param {T[]} list
+     * @returns {this}
+     */
+    setList(list: T[]): this;
+    /**
+     * Push items to the end of the list.
+     *
+     * @throws if the list is locked
+     * @param {T[]} items
+     * @returns {this}
+     */
+    push(...items: T[]): this;
+    /**
+     * Locks the list.
+     *
+     * @returns {this}
+     */
+    setLocked(): this;
+    /**
+     * Clear the list
+     */
+    clear(): void;
+    /**
+     * The get value at a particular index.
+     *
+     * @param {number} index
+     * @returns {T}
+     */
+    get(index: number): T;
+    /**
+     * Set value at index
+     *
+     * @param {number} index
+     * @param {T} item
+     * @returns {this}
+     */
+    set(index: number, item: T): this;
+    /**
+     * Set value at index if it's not already set
+     *
+     * @throws if the list is locked
+     * @param {number} index
+     * @param {() => T} lambda
+     * @returns {this}
+     */
+    setIfAbsent(index: number, lambda: () => T): this;
+    /**
+     * Get the current value, and advance the index
+     *
+     * @returns {T}
+     */
+    get next(): T;
+    /**
+     * Get the current value.
+     *
+     * @returns {T}
+     */
+    get current(): T;
+    /**
+     * Advance the index to the next element in a round robin fashion
+     *
+     * @returns {number}
+     */
+    advance(): number;
+    /**
+     * Is the list empty
+     *
+     * @returns {boolean}
+     */
+    get isEmpty(): boolean;
+    /**
+     * Get the length of the list
+     *
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * Shallow clone this list.
+     * Perhaps we should explicitly call this `shallowClone()` since it doesn't
+     * clone the list inside?
+     *
+     * @returns {List<T>}
+     */
+    clone(): List<T>;
+}

package/lib/transaction/List.js

@@ -0,0 +1,2 @@
+class t{constructor(){this.list=[],this.locked=!1,this.index=0}setList(t){if(this.locked)throw new Error("list is locked");return this.list=t,this.index=0,this}push(...t){if(this.locked)throw new Error("list is locked");return this.list.push(...t),this}setLocked(){return this.locked=!0,this}clear(){this.list=[],this.index=0,this.locked=!1}get(t){return this.list[t]}set(t,s){return t===this.length?this.list.push(s):this.list[t]=s,this}setIfAbsent(t,s){return t!=this.length&&null!=this.list[t]||this.set(t,s()),this}get next(){return this.get(this.advance())}get current(){return this.get(this.index)}advance(){const t=this.index;return this.index=(this.index+1)%this.list.length,t}get isEmpty(){return 0===this.length}get length(){return this.list.length}clone(){const s=new t;return s.list=this.list,s.locked=this.locked,s}}export{t as default};
+//# sourceMappingURL=List.js.map

package/lib/transaction/List.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"List.js","sources":["../../src/transaction/List.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * A custom list type which round robins, supports locking, and as additional\n * QoL improvements.\n *\n * @template {any} T\n */\nexport default class List {\n    constructor() {\n        /** @type {T[]} */\n        this.list = [];\n        this.locked = false;\n        this.index = 0;\n    }\n\n    /**\n     * Overwrite the entire list.\n     *\n     * @throws if the list is locked\n     * @param {T[]} list\n     * @returns {this}\n     */\n    setList(list) {\n        if (this.locked) {\n            throw new Error(\"list is locked\");\n        }\n\n        this.list = list;\n        this.index = 0;\n\n        return this;\n    }\n\n    /**\n     * Push items to the end of the list.\n     *\n     * @throws if the list is locked\n     * @param {T[]} items\n     * @returns {this}\n     */\n    push(...items) {\n        if (this.locked) {\n            throw new Error(\"list is locked\");\n        }\n\n        this.list.push(...items);\n        return this;\n    }\n\n    /**\n     * Locks the list.\n     *\n     * @returns {this}\n     */\n    setLocked() {\n        this.locked = true;\n        return this;\n    }\n\n    /**\n     * Clear the list\n     */\n    clear() {\n        this.list = [];\n        this.index = 0;\n        this.locked = false;\n    }\n\n    /**\n     * The get value at a particular index.\n     *\n     * @param {number} index\n     * @returns {T}\n     */\n    get(index) {\n        return this.list[index];\n    }\n\n    /**\n     * Set value at index\n     *\n     * @param {number} index\n     * @param {T} item\n     * @returns {this}\n     */\n    set(index, item) {\n        // QoL: If the index is at the end simply push the element to the end\n        if (index === this.length) {\n            this.list.push(item);\n        } else {\n            this.list[index] = item;\n        }\n\n        return this;\n    }\n\n    /**\n     * Set value at index if it's not already set\n     *\n     * @throws if the list is locked\n     * @param {number} index\n     * @param {() => T} lambda\n     * @returns {this}\n     */\n    setIfAbsent(index, lambda) {\n        if (index == this.length || this.list[index] == null) {\n            this.set(index, lambda());\n        }\n\n        return this;\n    }\n\n    /**\n     * Get the current value, and advance the index\n     *\n     * @returns {T}\n     */\n    get next() {\n        return this.get(this.advance());\n    }\n\n    /**\n     * Get the current value.\n     *\n     * @returns {T}\n     */\n    get current() {\n        return this.get(this.index);\n    }\n\n    /**\n     * Advance the index to the next element in a round robin fashion\n     *\n     * @returns {number}\n     */\n    advance() {\n        const index = this.index;\n        this.index = (this.index + 1) % this.list.length;\n        return index;\n    }\n\n    /**\n     * Is the list empty\n     *\n     * @returns {boolean}\n     */\n    get isEmpty() {\n        return this.length === 0;\n    }\n\n    /**\n     * Get the length of the list\n     *\n     * @returns {number}\n     */\n    get length() {\n        return this.list.length;\n    }\n\n    /**\n     * Shallow clone this list.\n     * Perhaps we should explicitly call this `shallowClone()` since it doesn't\n     * clone the list inside?\n     *\n     * @returns {List<T>}\n     */\n    clone() {\n        /** @type {List<T>} */\n        const list = new List();\n        list.list = this.list;\n        list.locked = this.locked;\n        return list;\n    }\n}\n"],"names":["List","constructor","this","list","locked","index","setList","Error","push","items","setLocked","clear","get","set","item","length","setIfAbsent","lambda","next","advance","current","isEmpty","clone"],"mappings":"AAQe,MAAMA,EACjB,WAAAC,GAEIC,KAAKC,KAAO,GACZD,KAAKE,QAAS,EACdF,KAAKG,MAAQ,CACrB,CASI,OAAAC,CAAQH,GACJ,GAAID,KAAKE,OACL,MAAM,IAAIG,MAAM,kBAMpB,OAHAL,KAAKC,KAAOA,EACZD,KAAKG,MAAQ,EAENH,IACf,CASI,IAAAM,IAAQC,GACJ,GAAIP,KAAKE,OACL,MAAM,IAAIG,MAAM,kBAIpB,OADAL,KAAKC,KAAKK,QAAQC,GACXP,IACf,CAOI,SAAAQ,GAEI,OADAR,KAAKE,QAAS,EACPF,IACf,CAKI,KAAAS,GACIT,KAAKC,KAAO,GACZD,KAAKG,MAAQ,EACbH,KAAKE,QAAS,CACtB,CAQI,GAAAQ,CAAIP,GACA,OAAOH,KAAKC,KAAKE,EACzB,CASI,GAAAQ,CAAIR,EAAOS,GAQP,OANIT,IAAUH,KAAKa,OACfb,KAAKC,KAAKK,KAAKM,GAEfZ,KAAKC,KAAKE,GAASS,EAGhBZ,IACf,CAUI,WAAAc,CAAYX,EAAOY,GAKf,OAJIZ,GAASH,KAAKa,QAA8B,MAApBb,KAAKC,KAAKE,IAClCH,KAAKW,IAAIR,EAAOY,KAGbf,IACf,CAOI,QAAIgB,GACA,OAAOhB,KAAKU,IAAIV,KAAKiB,UAC7B,CAOI,WAAIC,GACA,OAAOlB,KAAKU,IAAIV,KAAKG,MAC7B,CAOI,OAAAc,GACI,MAAMd,EAAQH,KAAKG,MAEnB,OADAH,KAAKG,OAASH,KAAKG,MAAQ,GAAKH,KAAKC,KAAKY,OACnCV,CACf,CAOI,WAAIgB,GACA,OAAuB,IAAhBnB,KAAKa,MACpB,CAOI,UAAIA,GACA,OAAOb,KAAKC,KAAKY,MACzB,CASI,KAAAO,GAEI,MAAMnB,EAAO,IAAIH,EAGjB,OAFAG,EAAKA,KAAOD,KAAKC,KACjBA,EAAKC,OAASF,KAAKE,OACZD,CACf"}