@fuel-ts/account 0.93.0 → 0.94.1

package/dist/index.global.js

@@ -20390,9 +20390,9 @@ spurious results.`);
     }
   });
 
-  // ../../node_modules/.pnpm/@fuels+vm-asm@0.55.0/node_modules/@fuels/vm-asm/dist/node/index.cjs
+  // ../../node_modules/.pnpm/@fuels+vm-asm@0.56.0/node_modules/@fuels/vm-asm/dist/node/index.cjs
   var require_node = __commonJS({
-    "../../node_modules/.pnpm/@fuels+vm-asm@0.55.0/node_modules/@fuels/vm-asm/dist/node/index.cjs"(exports) {
+    "../../node_modules/.pnpm/@fuels+vm-asm@0.56.0/node_modules/@fuels/vm-asm/dist/node/index.cjs"(exports) {
       "use strict";
       var wasm$1;
       var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
@@ -20606,8 +20606,8 @@ spurious results.`);
         const ret3 = wasm$1.cb(dst);
         return Instruction.__wrap(ret3);
       }
-      function ldc(contract_id_addr, offset, len) {
-        const ret3 = wasm$1.ldc(contract_id_addr, offset, len);
+      function ldc(contract_id_addr, offset, len, mode) {
+        const ret3 = wasm$1.ldc(contract_id_addr, offset, len, mode);
         return Instruction.__wrap(ret3);
       }
       function log(a, b, c, d) {
@@ -20662,8 +20662,8 @@ spurious results.`);
         const ret3 = wasm$1.ecr1(dst_addr, sig_addr, msg_hash_addr);
         return Instruction.__wrap(ret3);
       }
-      function ed19(pub_key_addr, sig_addr, msg_hash_addr) {
-        const ret3 = wasm$1.ed19(pub_key_addr, sig_addr, msg_hash_addr);
+      function ed19(pub_key_addr, sig_addr, msg_addr, msg_len) {
+        const ret3 = wasm$1.ed19(pub_key_addr, sig_addr, msg_addr, msg_len);
         return Instruction.__wrap(ret3);
       }
       function k256(dst_addr, src_addr, len) {
@@ -20910,6 +20910,14 @@ spurious results.`);
         const ret3 = wasm$1.ecal(a, b, c, d);
         return Instruction.__wrap(ret3);
       }
+      function bsiz(dst, blob_id_ptr) {
+        const ret3 = wasm$1.bsiz(dst, blob_id_ptr);
+        return Instruction.__wrap(ret3);
+      }
+      function bldd(dst_ptr, blob_id_ptr, offset, len) {
+        const ret3 = wasm$1.bldd(dst_ptr, blob_id_ptr, offset, len);
+        return Instruction.__wrap(ret3);
+      }
       var cachedInt32Memory0 = null;
       function getInt32Memory0() {
         if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
@@ -20921,643 +20929,695 @@ spurious results.`);
         ptr = ptr >>> 0;
         return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
       }
-      var GTFArgs2 = Object.freeze({
+      var GMArgs = Object.freeze({
         /**
-        *r" Set `$rA` to `tx.type`
+        *r" Get if caller is external.
         */
-        Type: 1,
-        "1": "Type",
+        IsCallerExternal: 1,
+        "1": "IsCallerExternal",
         /**
-        *r" Set `$rA` to `tx.scriptGasLimit`
+        *r" Get caller's contract ID.
         */
-        ScriptGasLimit: 2,
-        "2": "ScriptGasLimit",
+        GetCaller: 2,
+        "2": "GetCaller",
         /**
-        *r" Set `$rA` to `tx.scriptLength`
+        *r" Get index of current predicate.
         */
-        ScriptLength: 3,
-        "3": "ScriptLength",
+        GetVerifyingPredicate: 3,
+        "3": "GetVerifyingPredicate",
         /**
-        *r" Set `$rA` to `tx.scriptDataLength`
+        *r" Get the Chain ID this VM is operating within
         */
-        ScriptDataLength: 4,
-        "4": "ScriptDataLength",
+        GetChainId: 4,
+        "4": "GetChainId",
         /**
-        *r" Set `$rA` to `tx.inputsCount`
+        *r" Get memory address where the transaction is located
         */
-        ScriptInputsCount: 5,
-        "5": "ScriptInputsCount",
+        TxStart: 5,
+        "5": "TxStart",
         /**
-        *r" Set `$rA` to `tx.outputsCount`
+        *r" Get memory address of base asset ID
         */
-        ScriptOutputsCount: 6,
-        "6": "ScriptOutputsCount",
+        BaseAssetId: 6,
+        "6": "BaseAssetId"
+      });
+      var CompareMode = Object.freeze({
         /**
-        *r" Set `$rA` to `tx.witnessesCount`
+        * Equality (`==`)
         */
-        ScriptWitnessesCount: 7,
-        "7": "ScriptWitnessesCount",
+        EQ: 0,
+        "0": "EQ",
         /**
-        *r" Set `$rA` to `Memory address of tx.script`
+        * Inequality (`!=`)
         */
-        Script: 9,
-        "9": "Script",
+        NE: 1,
+        "1": "NE",
         /**
-        *r" Set `$rA` to `Memory address of tx.scriptData`
+        * Less than (`<`)
         */
-        ScriptData: 10,
-        "10": "ScriptData",
+        LT: 2,
+        "2": "LT",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB]`
+        * Greater than (`>`)
         */
-        ScriptInputAtIndex: 11,
-        "11": "ScriptInputAtIndex",
+        GT: 3,
+        "3": "GT",
         /**
-        *r" Set `$rA` to `Memory address of t.outputs[$rB]`
+        * Less than or equals (`>=`)
         */
-        ScriptOutputAtIndex: 12,
-        "12": "ScriptOutputAtIndex",
+        LTE: 4,
+        "4": "LTE",
         /**
-        *r" Set `$rA` to `Memory address of tx.witnesses[$rB]`
+        * Greater than or equals (`>=`)
         */
-        ScriptWitnessAtIndex: 13,
-        "13": "ScriptWitnessAtIndex",
+        GTE: 5,
+        "5": "GTE",
         /**
-        *r" Set `$rA` to size of the transaction in memory, in bytes
+        * Number of leading zeroes in lhs (`lzcnt`) (discards rhs)
         */
-        TxLength: 14,
-        "14": "TxLength",
+        LZC: 6,
+        "6": "LZC"
+      });
+      var PanicReason = Object.freeze({
         /**
-        *r" Set `$rA` to `tx.bytecodeWitnessIndex`
+        *r" The byte can't be mapped to any known `PanicReason`.
         */
-        CreateBytecodeWitnessIndex: 257,
-        "257": "CreateBytecodeWitnessIndex",
+        UnknownPanicReason: 0,
+        "0": "UnknownPanicReason",
         /**
-        *r" Set `$rA` to `tx.storageSlotsCount`
+        *r" Found `RVRT` instruction.
         */
-        CreateStorageSlotsCount: 258,
-        "258": "CreateStorageSlotsCount",
+        Revert: 1,
+        "1": "Revert",
         /**
-        *r" Set `$rA` to `tx.inputsCount`
+        *r" Execution ran out of gas.
         */
-        CreateInputsCount: 259,
-        "259": "CreateInputsCount",
+        OutOfGas: 2,
+        "2": "OutOfGas",
         /**
-        *r" Set `$rA` to `tx.outputsCount`
+        *r" The transaction validity is violated.
         */
-        CreateOutputsCount: 260,
-        "260": "CreateOutputsCount",
+        TransactionValidity: 3,
+        "3": "TransactionValidity",
         /**
-        *r" Set `$rA` to `tx.witnessesCount`
+        *r" Attempt to write outside interpreter memory boundaries.
         */
-        CreateWitnessesCount: 261,
-        "261": "CreateWitnessesCount",
+        MemoryOverflow: 4,
+        "4": "MemoryOverflow",
         /**
-        *r" Set `$rA` to `Memory address of tx.salt`
+        *r" Overflow while executing arithmetic operation.
+        *r" These errors are ignored using the WRAPPING flag.
         */
-        CreateSalt: 262,
-        "262": "CreateSalt",
+        ArithmeticOverflow: 5,
+        "5": "ArithmeticOverflow",
         /**
-        *r" Set `$rA` to `Memory address of tx.storageSlots[$rB]`
+        *r" Designed contract was not found in the storage.
         */
-        CreateStorageSlotAtIndex: 263,
-        "263": "CreateStorageSlotAtIndex",
+        ContractNotFound: 6,
+        "6": "ContractNotFound",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB]`
+        *r" Memory ownership rules are violated.
         */
-        CreateInputAtIndex: 264,
-        "264": "CreateInputAtIndex",
+        MemoryOwnership: 7,
+        "7": "MemoryOwnership",
         /**
-        *r" Set `$rA` to `Memory address of t.outputs[$rB]`
+        *r" The asset ID balance isn't enough for the instruction.
         */
-        CreateOutputAtIndex: 265,
-        "265": "CreateOutputAtIndex",
+        NotEnoughBalance: 8,
+        "8": "NotEnoughBalance",
         /**
-        *r" Set `$rA` to `Memory address of tx.witnesses[$rB]`
+        *r" The interpreter is expected to be in internal context.
         */
-        CreateWitnessAtIndex: 266,
-        "266": "CreateWitnessAtIndex",
+        ExpectedInternalContext: 9,
+        "9": "ExpectedInternalContext",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].type`
+        *r" The queried asset ID was not found in the state.
         */
-        InputType: 512,
-        "512": "InputType",
+        AssetIdNotFound: 10,
+        "10": "AssetIdNotFound",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].txID`
+        *r" The provided input is not found in the transaction.
         */
-        InputCoinTxId: 513,
-        "513": "InputCoinTxId",
+        InputNotFound: 11,
+        "11": "InputNotFound",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].outputIndex`
+        *r" The provided output is not found in the transaction.
         */
-        InputCoinOutputIndex: 514,
-        "514": "InputCoinOutputIndex",
+        OutputNotFound: 12,
+        "12": "OutputNotFound",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].owner`
+        *r" The provided witness is not found in the transaction.
         */
-        InputCoinOwner: 515,
-        "515": "InputCoinOwner",
+        WitnessNotFound: 13,
+        "13": "WitnessNotFound",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].amount`
+        *r" The transaction maturity is not valid for this request.
         */
-        InputCoinAmount: 516,
-        "516": "InputCoinAmount",
+        TransactionMaturity: 14,
+        "14": "TransactionMaturity",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].asset_id`
+        *r" The metadata identifier is invalid.
         */
-        InputCoinAssetId: 517,
-        "517": "InputCoinAssetId",
+        InvalidMetadataIdentifier: 15,
+        "15": "InvalidMetadataIdentifier",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].txPointer`
+        *r" The call structure is not valid.
         */
-        InputCoinTxPointer: 518,
-        "518": "InputCoinTxPointer",
+        MalformedCallStructure: 16,
+        "16": "MalformedCallStructure",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].witnessIndex`
+        *r" The provided register does not allow write operations.
         */
-        InputCoinWitnessIndex: 519,
-        "519": "InputCoinWitnessIndex",
+        ReservedRegisterNotWritable: 17,
+        "17": "ReservedRegisterNotWritable",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].predicateLength`
+        *r" The execution resulted in an erroneous state of the interpreter.
         */
-        InputCoinPredicateLength: 521,
-        "521": "InputCoinPredicateLength",
+        InvalidFlags: 18,
+        "18": "InvalidFlags",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].predicateDataLength`
+        *r" The provided immediate value is not valid for this instruction.
         */
-        InputCoinPredicateDataLength: 522,
-        "522": "InputCoinPredicateDataLength",
+        InvalidImmediateValue: 19,
+        "19": "InvalidImmediateValue",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicate`
+        *r" The provided transaction input is not of type `Coin`.
         */
-        InputCoinPredicate: 523,
-        "523": "InputCoinPredicate",
+        ExpectedCoinInput: 20,
+        "20": "ExpectedCoinInput",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicateData`
+        *r" `ECAL` instruction failed.
         */
-        InputCoinPredicateData: 524,
-        "524": "InputCoinPredicateData",
+        EcalError: 21,
+        "21": "EcalError",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicateGasUsed`
+        *r" Two segments of the interpreter memory should not intersect for write operations.
         */
-        InputCoinPredicateGasUsed: 525,
-        "525": "InputCoinPredicateGasUsed",
+        MemoryWriteOverlap: 22,
+        "22": "MemoryWriteOverlap",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].txID`
+        *r" The requested contract is not listed in the transaction inputs.
         */
-        InputContractTxId: 544,
-        "544": "InputContractTxId",
+        ContractNotInInputs: 23,
+        "23": "ContractNotInInputs",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].outputIndex`
+        *r" The internal asset ID balance overflowed with the provided instruction.
         */
-        InputContractOutputIndex: 545,
-        "545": "InputContractOutputIndex",
+        InternalBalanceOverflow: 24,
+        "24": "InternalBalanceOverflow",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].contractID`
+        *r" The maximum allowed contract size is violated.
         */
-        InputContractId: 549,
-        "549": "InputContractId",
+        ContractMaxSize: 25,
+        "25": "ContractMaxSize",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].sender`
+        *r" This instruction expects the stack area to be unallocated for this call.
         */
-        InputMessageSender: 576,
-        "576": "InputMessageSender",
+        ExpectedUnallocatedStack: 26,
+        "26": "ExpectedUnallocatedStack",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].recipient`
+        *r" The maximum allowed number of static contracts was reached for this transaction.
         */
-        InputMessageRecipient: 577,
-        "577": "InputMessageRecipient",
-        /**
-        *r" Set `$rA` to `tx.inputs[$rB].amount`
+        MaxStaticContractsReached: 27,
+        "27": "MaxStaticContractsReached",
+        /**
+        *r" The requested transfer amount cannot be zero.
         */
-        InputMessageAmount: 578,
-        "578": "InputMessageAmount",
+        TransferAmountCannotBeZero: 28,
+        "28": "TransferAmountCannotBeZero",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].nonce`
+        *r" The provided transaction output should be of type `Variable`.
         */
-        InputMessageNonce: 579,
-        "579": "InputMessageNonce",
+        ExpectedOutputVariable: 29,
+        "29": "ExpectedOutputVariable",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].witnessIndex`
+        *r" The expected context of the stack parent is internal.
         */
-        InputMessageWitnessIndex: 580,
-        "580": "InputMessageWitnessIndex",
+        ExpectedParentInternalContext: 30,
+        "30": "ExpectedParentInternalContext",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].dataLength`
+        *r" The predicate returned non `1`. The `1` means successful verification
+        *r" of the predicate, all other values means unsuccessful.
         */
-        InputMessageDataLength: 581,
-        "581": "InputMessageDataLength",
+        PredicateReturnedNonOne: 31,
+        "31": "PredicateReturnedNonOne",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].predicateLength`
+        *r" The contract ID is already deployed and can't be overwritten.
         */
-        InputMessagePredicateLength: 582,
-        "582": "InputMessagePredicateLength",
+        ContractIdAlreadyDeployed: 32,
+        "32": "ContractIdAlreadyDeployed",
         /**
-        *r" Set `$rA` to `tx.inputs[$rB].predicateDataLength`
+        *r" The loaded contract mismatch expectations.
         */
-        InputMessagePredicateDataLength: 583,
-        "583": "InputMessagePredicateDataLength",
+        ContractMismatch: 33,
+        "33": "ContractMismatch",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].data`
+        *r" Attempting to send message data longer than `MAX_MESSAGE_DATA_LENGTH`
         */
-        InputMessageData: 584,
-        "584": "InputMessageData",
+        MessageDataTooLong: 34,
+        "34": "MessageDataTooLong",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicate`
+        *r" Mathematically invalid arguments where given to an arithmetic instruction.
+        *r" For instance, division by zero produces this.
+        *r" These errors are ignored using the UNSAFEMATH flag.
         */
-        InputMessagePredicate: 585,
-        "585": "InputMessagePredicate",
+        ArithmeticError: 35,
+        "35": "ArithmeticError",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicateData`
+        *r" The contract instruction is not allowed in predicates.
         */
-        InputMessagePredicateData: 586,
-        "586": "InputMessagePredicateData",
+        ContractInstructionNotAllowed: 36,
+        "36": "ContractInstructionNotAllowed",
         /**
-        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicateGasUsed`
+        *r" Transfer of zero coins is not allowed.
         */
-        InputMessagePredicateGasUsed: 587,
-        "587": "InputMessagePredicateGasUsed",
+        TransferZeroCoins: 37,
+        "37": "TransferZeroCoins",
         /**
-        *r" Set `$rA` to `tx.outputs[$rB].type`
+        *r" Attempted to execute an invalid instruction
         */
-        OutputType: 768,
-        "768": "OutputType",
+        InvalidInstruction: 38,
+        "38": "InvalidInstruction",
         /**
-        *r" Set `$rA` to `Memory address of tx.outputs[$rB].to`
+        *r" Memory outside $is..$ssp range is not executable
         */
-        OutputCoinTo: 769,
-        "769": "OutputCoinTo",
+        MemoryNotExecutable: 39,
+        "39": "MemoryNotExecutable",
         /**
-        *r" Set `$rA` to `tx.outputs[$rB].amount`
+        *r" The policy is not set.
         */
-        OutputCoinAmount: 770,
-        "770": "OutputCoinAmount",
+        PolicyIsNotSet: 40,
+        "40": "PolicyIsNotSet",
         /**
-        *r" Set `$rA` to `Memory address of tx.outputs[$rB].asset_id`
+        *r" The policy is not found across policies.
         */
-        OutputCoinAssetId: 771,
-        "771": "OutputCoinAssetId",
+        PolicyNotFound: 41,
+        "41": "PolicyNotFound",
         /**
-        *r" Set `$rA` to `tx.outputs[$rB].inputIndex`
+        *r" Receipt context is full
         */
-        OutputContractInputIndex: 772,
-        "772": "OutputContractInputIndex",
+        TooManyReceipts: 42,
+        "42": "TooManyReceipts",
         /**
-        *r" Set `$rA` to `Memory address of tx.outputs[$rB].contractID`
+        *r" Balance of a contract overflowed
         */
-        OutputContractCreatedContractId: 775,
-        "775": "OutputContractCreatedContractId",
+        BalanceOverflow: 43,
+        "43": "BalanceOverflow",
         /**
-        *r" Set `$rA` to `Memory address of tx.outputs[$rB].stateRoot`
+        *r" Block height value is invalid, typically because it is too large
         */
-        OutputContractCreatedStateRoot: 776,
-        "776": "OutputContractCreatedStateRoot",
+        InvalidBlockHeight: 44,
+        "44": "InvalidBlockHeight",
         /**
-        *r" Set `$rA` to `tx.witnesses[$rB].dataLength`
+        *r" Attempt to use sequential memory instructions with too large slot count,
+        *r" typically because it cannot fit into usize
         */
-        WitnessDataLength: 1024,
-        "1024": "WitnessDataLength",
+        TooManySlots: 45,
+        "45": "TooManySlots",
         /**
-        *r" Set `$rA` to `Memory address of tx.witnesses[$rB].data`
+        *r" Caller of this internal context is also expected to be internal,
+        *r" i.e. $fp->$fp must be non-zero.
         */
-        WitnessData: 1025,
-        "1025": "WitnessData",
+        ExpectedNestedCaller: 46,
+        "46": "ExpectedNestedCaller",
         /**
-        *r" Set `$rA` to `tx.policyTypes`
+        *r" During memory growth, the stack overlapped with the heap
         */
-        PolicyTypes: 1280,
-        "1280": "PolicyTypes",
+        MemoryGrowthOverlap: 47,
+        "47": "MemoryGrowthOverlap",
         /**
-        *r" Set `$rA` to `tx.policies[0x00].gasPrice`
+        *r" Attempting to read or write uninitialized memory.
+        *r" Also occurs when boundary crosses from stack to heap.
         */
-        PolicyTip: 1281,
-        "1281": "PolicyTip",
+        UninitalizedMemoryAccess: 48,
+        "48": "UninitalizedMemoryAccess",
         /**
-        *r" Set `$rA` to `tx.policies[count_ones(0b11 & tx.policyTypes) - 1].witnessLimit`
+        *r" Overriding consensus parameters is not allowed.
         */
-        PolicyWitnessLimit: 1282,
-        "1282": "PolicyWitnessLimit",
+        OverridingConsensusParameters: 49,
+        "49": "OverridingConsensusParameters",
         /**
-        *r" Set `$rA` to `tx.policies[count_ones(0b111 & tx.policyTypes) - 1].maturity`
+        *r" The storage doesn't know about the hash of the state transition bytecode.
         */
-        PolicyMaturity: 1283,
-        "1283": "PolicyMaturity",
+        UnknownStateTransactionBytecodeRoot: 50,
+        "50": "UnknownStateTransactionBytecodeRoot",
         /**
-        *r" Set `$rA` to `tx.policies[count_ones(0b1111 & tx.policyTypes) - 1].maxFee`
+        *r" Overriding the state transition bytecode is not allowed.
         */
-        PolicyMaxFee: 1284,
-        "1284": "PolicyMaxFee"
+        OverridingStateTransactionBytecode: 51,
+        "51": "OverridingStateTransactionBytecode",
+        /**
+        *r" The bytecode is already uploaded and cannot be uploaded again.
+        */
+        BytecodeAlreadyUploaded: 52,
+        "52": "BytecodeAlreadyUploaded",
+        /**
+        *r" The part of the bytecode is not sequentially connected to the previous parts.
+        */
+        ThePartIsNotSequentiallyConnected: 53,
+        "53": "ThePartIsNotSequentiallyConnected",
+        /**
+        *r" The requested blob is not found.
+        */
+        BlobNotFound: 54,
+        "54": "BlobNotFound",
+        /**
+        *r" The blob was already
+        */
+        BlobIdAlreadyUploaded: 55,
+        "55": "BlobIdAlreadyUploaded",
+        /**
+        *r" Active gas costs do not define the cost for this instruction.
+        */
+        GasCostNotDefined: 56,
+        "56": "GasCostNotDefined"
       });
-      var PanicReason = Object.freeze({
+      var GTFArgs2 = Object.freeze({
         /**
-        *r" The byte can't be mapped to any known `PanicReason`.
+        *r" Set `$rA` to `tx.type`
         */
-        UnknownPanicReason: 0,
-        "0": "UnknownPanicReason",
+        Type: 1,
+        "1": "Type",
         /**
-        *r" Found `RVRT` instruction.
+        *r" Set `$rA` to `tx.scriptGasLimit`
         */
-        Revert: 1,
-        "1": "Revert",
+        ScriptGasLimit: 2,
+        "2": "ScriptGasLimit",
         /**
-        *r" Execution ran out of gas.
+        *r" Set `$rA` to `tx.scriptLength`
         */
-        OutOfGas: 2,
-        "2": "OutOfGas",
+        ScriptLength: 3,
+        "3": "ScriptLength",
         /**
-        *r" The transaction validity is violated.
+        *r" Set `$rA` to `tx.scriptDataLength`
         */
-        TransactionValidity: 3,
-        "3": "TransactionValidity",
+        ScriptDataLength: 4,
+        "4": "ScriptDataLength",
         /**
-        *r" Attempt to write outside interpreter memory boundaries.
+        *r" Set `$rA` to `tx.inputsCount`
         */
-        MemoryOverflow: 4,
-        "4": "MemoryOverflow",
+        ScriptInputsCount: 5,
+        "5": "ScriptInputsCount",
         /**
-        *r" Overflow while executing arithmetic operation.
-        *r" These errors are ignored using the WRAPPING flag.
+        *r" Set `$rA` to `tx.outputsCount`
         */
-        ArithmeticOverflow: 5,
-        "5": "ArithmeticOverflow",
+        ScriptOutputsCount: 6,
+        "6": "ScriptOutputsCount",
         /**
-        *r" Designed contract was not found in the storage.
+        *r" Set `$rA` to `tx.witnessesCount`
         */
-        ContractNotFound: 6,
-        "6": "ContractNotFound",
+        ScriptWitnessesCount: 7,
+        "7": "ScriptWitnessesCount",
         /**
-        *r" Memory ownership rules are violated.
+        *r" Set `$rA` to `Memory address of tx.script`
         */
-        MemoryOwnership: 7,
-        "7": "MemoryOwnership",
+        Script: 9,
+        "9": "Script",
         /**
-        *r" The asset ID balance isn't enough for the instruction.
+        *r" Set `$rA` to `Memory address of tx.scriptData`
         */
-        NotEnoughBalance: 8,
-        "8": "NotEnoughBalance",
+        ScriptData: 10,
+        "10": "ScriptData",
         /**
-        *r" The interpreter is expected to be in internal context.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB]`
         */
-        ExpectedInternalContext: 9,
-        "9": "ExpectedInternalContext",
+        ScriptInputAtIndex: 11,
+        "11": "ScriptInputAtIndex",
         /**
-        *r" The queried asset ID was not found in the state.
+        *r" Set `$rA` to `Memory address of t.outputs[$rB]`
         */
-        AssetIdNotFound: 10,
-        "10": "AssetIdNotFound",
+        ScriptOutputAtIndex: 12,
+        "12": "ScriptOutputAtIndex",
         /**
-        *r" The provided input is not found in the transaction.
+        *r" Set `$rA` to `Memory address of tx.witnesses[$rB]`
         */
-        InputNotFound: 11,
-        "11": "InputNotFound",
+        ScriptWitnessAtIndex: 13,
+        "13": "ScriptWitnessAtIndex",
         /**
-        *r" The provided output is not found in the transaction.
+        *r" Set `$rA` to size of the transaction in memory, in bytes
         */
-        OutputNotFound: 12,
-        "12": "OutputNotFound",
+        TxLength: 14,
+        "14": "TxLength",
         /**
-        *r" The provided witness is not found in the transaction.
+        *r" Set `$rA` to `tx.bytecodeWitnessIndex`
         */
-        WitnessNotFound: 13,
-        "13": "WitnessNotFound",
+        CreateBytecodeWitnessIndex: 257,
+        "257": "CreateBytecodeWitnessIndex",
         /**
-        *r" The transaction maturity is not valid for this request.
+        *r" Set `$rA` to `tx.storageSlotsCount`
         */
-        TransactionMaturity: 14,
-        "14": "TransactionMaturity",
+        CreateStorageSlotsCount: 258,
+        "258": "CreateStorageSlotsCount",
         /**
-        *r" The metadata identifier is invalid.
+        *r" Set `$rA` to `tx.inputsCount`
         */
-        InvalidMetadataIdentifier: 15,
-        "15": "InvalidMetadataIdentifier",
+        CreateInputsCount: 259,
+        "259": "CreateInputsCount",
         /**
-        *r" The call structure is not valid.
+        *r" Set `$rA` to `tx.outputsCount`
         */
-        MalformedCallStructure: 16,
-        "16": "MalformedCallStructure",
+        CreateOutputsCount: 260,
+        "260": "CreateOutputsCount",
         /**
-        *r" The provided register does not allow write operations.
+        *r" Set `$rA` to `tx.witnessesCount`
         */
-        ReservedRegisterNotWritable: 17,
-        "17": "ReservedRegisterNotWritable",
+        CreateWitnessesCount: 261,
+        "261": "CreateWitnessesCount",
         /**
-        *r" The execution resulted in an erroneous state of the interpreter.
+        *r" Set `$rA` to `Memory address of tx.salt`
         */
-        InvalidFlags: 18,
-        "18": "InvalidFlags",
+        CreateSalt: 262,
+        "262": "CreateSalt",
         /**
-        *r" The provided immediate value is not valid for this instruction.
+        *r" Set `$rA` to `Memory address of tx.storageSlots[$rB]`
         */
-        InvalidImmediateValue: 19,
-        "19": "InvalidImmediateValue",
+        CreateStorageSlotAtIndex: 263,
+        "263": "CreateStorageSlotAtIndex",
         /**
-        *r" The provided transaction input is not of type `Coin`.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB]`
         */
-        ExpectedCoinInput: 20,
-        "20": "ExpectedCoinInput",
+        CreateInputAtIndex: 264,
+        "264": "CreateInputAtIndex",
         /**
-        *r" `ECAL` instruction failed.
+        *r" Set `$rA` to `Memory address of t.outputs[$rB]`
         */
-        EcalError: 21,
-        "21": "EcalError",
+        CreateOutputAtIndex: 265,
+        "265": "CreateOutputAtIndex",
         /**
-        *r" Two segments of the interpreter memory should not intersect for write operations.
+        *r" Set `$rA` to `Memory address of tx.witnesses[$rB]`
         */
-        MemoryWriteOverlap: 22,
-        "22": "MemoryWriteOverlap",
+        CreateWitnessAtIndex: 266,
+        "266": "CreateWitnessAtIndex",
         /**
-        *r" The requested contract is not listed in the transaction inputs.
+        *r" Set `$rA` to `tx.inputs[$rB].type`
         */
-        ContractNotInInputs: 23,
-        "23": "ContractNotInInputs",
+        InputType: 512,
+        "512": "InputType",
         /**
-        *r" The internal asset ID balance overflowed with the provided instruction.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].txID`
         */
-        InternalBalanceOverflow: 24,
-        "24": "InternalBalanceOverflow",
+        InputCoinTxId: 513,
+        "513": "InputCoinTxId",
         /**
-        *r" The maximum allowed contract size is violated.
+        *r" Set `$rA` to `tx.inputs[$rB].outputIndex`
         */
-        ContractMaxSize: 25,
-        "25": "ContractMaxSize",
+        InputCoinOutputIndex: 514,
+        "514": "InputCoinOutputIndex",
         /**
-        *r" This instruction expects the stack area to be unallocated for this call.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].owner`
         */
-        ExpectedUnallocatedStack: 26,
-        "26": "ExpectedUnallocatedStack",
+        InputCoinOwner: 515,
+        "515": "InputCoinOwner",
         /**
-        *r" The maximum allowed number of static contracts was reached for this transaction.
+        *r" Set `$rA` to `tx.inputs[$rB].amount`
         */
-        MaxStaticContractsReached: 27,
-        "27": "MaxStaticContractsReached",
+        InputCoinAmount: 516,
+        "516": "InputCoinAmount",
         /**
-        *r" The requested transfer amount cannot be zero.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].asset_id`
         */
-        TransferAmountCannotBeZero: 28,
-        "28": "TransferAmountCannotBeZero",
+        InputCoinAssetId: 517,
+        "517": "InputCoinAssetId",
         /**
-        *r" The provided transaction output should be of type `Variable`.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].txPointer`
         */
-        ExpectedOutputVariable: 29,
-        "29": "ExpectedOutputVariable",
+        InputCoinTxPointer: 518,
+        "518": "InputCoinTxPointer",
         /**
-        *r" The expected context of the stack parent is internal.
+        *r" Set `$rA` to `tx.inputs[$rB].witnessIndex`
         */
-        ExpectedParentInternalContext: 30,
-        "30": "ExpectedParentInternalContext",
+        InputCoinWitnessIndex: 519,
+        "519": "InputCoinWitnessIndex",
         /**
-        *r" The predicate returned non `1`. The `1` means successful verification
-        *r" of the predicate, all other values means unsuccessful.
+        *r" Set `$rA` to `tx.inputs[$rB].predicateLength`
         */
-        PredicateReturnedNonOne: 31,
-        "31": "PredicateReturnedNonOne",
+        InputCoinPredicateLength: 521,
+        "521": "InputCoinPredicateLength",
         /**
-        *r" The contract ID is already deployed and can't be overwritten.
+        *r" Set `$rA` to `tx.inputs[$rB].predicateDataLength`
         */
-        ContractIdAlreadyDeployed: 32,
-        "32": "ContractIdAlreadyDeployed",
+        InputCoinPredicateDataLength: 522,
+        "522": "InputCoinPredicateDataLength",
         /**
-        *r" The loaded contract mismatch expectations.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicate`
         */
-        ContractMismatch: 33,
-        "33": "ContractMismatch",
+        InputCoinPredicate: 523,
+        "523": "InputCoinPredicate",
         /**
-        *r" Attempting to send message data longer than `MAX_MESSAGE_DATA_LENGTH`
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicateData`
         */
-        MessageDataTooLong: 34,
-        "34": "MessageDataTooLong",
+        InputCoinPredicateData: 524,
+        "524": "InputCoinPredicateData",
         /**
-        *r" Mathematically invalid arguments where given to an arithmetic instruction.
-        *r" For instance, division by zero produces this.
-        *r" These errors are ignored using the UNSAFEMATH flag.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicateGasUsed`
         */
-        ArithmeticError: 35,
-        "35": "ArithmeticError",
+        InputCoinPredicateGasUsed: 525,
+        "525": "InputCoinPredicateGasUsed",
         /**
-        *r" The contract instruction is not allowed in predicates.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].txID`
         */
-        ContractInstructionNotAllowed: 36,
-        "36": "ContractInstructionNotAllowed",
+        InputContractTxId: 544,
+        "544": "InputContractTxId",
         /**
-        *r" Transfer of zero coins is not allowed.
+        *r" Set `$rA` to `tx.inputs[$rB].outputIndex`
         */
-        TransferZeroCoins: 37,
-        "37": "TransferZeroCoins",
+        InputContractOutputIndex: 545,
+        "545": "InputContractOutputIndex",
         /**
-        *r" Attempted to execute an invalid instruction
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].contractID`
         */
-        InvalidInstruction: 38,
-        "38": "InvalidInstruction",
+        InputContractId: 549,
+        "549": "InputContractId",
         /**
-        *r" Memory outside $is..$ssp range is not executable
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].sender`
         */
-        MemoryNotExecutable: 39,
-        "39": "MemoryNotExecutable",
+        InputMessageSender: 576,
+        "576": "InputMessageSender",
         /**
-        *r" The policy is not set.
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].recipient`
         */
-        PolicyIsNotSet: 40,
-        "40": "PolicyIsNotSet",
+        InputMessageRecipient: 577,
+        "577": "InputMessageRecipient",
         /**
-        *r" The policy is not found across policies.
+        *r" Set `$rA` to `tx.inputs[$rB].amount`
         */
-        PolicyNotFound: 41,
-        "41": "PolicyNotFound",
+        InputMessageAmount: 578,
+        "578": "InputMessageAmount",
         /**
-        *r" Receipt context is full
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].nonce`
         */
-        TooManyReceipts: 42,
-        "42": "TooManyReceipts",
+        InputMessageNonce: 579,
+        "579": "InputMessageNonce",
         /**
-        *r" Balance of a contract overflowed
+        *r" Set `$rA` to `tx.inputs[$rB].witnessIndex`
         */
-        BalanceOverflow: 43,
-        "43": "BalanceOverflow",
+        InputMessageWitnessIndex: 580,
+        "580": "InputMessageWitnessIndex",
         /**
-        *r" Block height value is invalid, typically because it is too large
+        *r" Set `$rA` to `tx.inputs[$rB].dataLength`
         */
-        InvalidBlockHeight: 44,
-        "44": "InvalidBlockHeight",
+        InputMessageDataLength: 581,
+        "581": "InputMessageDataLength",
         /**
-        *r" Attempt to use sequential memory instructions with too large slot count,
-        *r" typically because it cannot fit into usize
+        *r" Set `$rA` to `tx.inputs[$rB].predicateLength`
         */
-        TooManySlots: 45,
-        "45": "TooManySlots",
+        InputMessagePredicateLength: 582,
+        "582": "InputMessagePredicateLength",
+        /**
+        *r" Set `$rA` to `tx.inputs[$rB].predicateDataLength`
+        */
+        InputMessagePredicateDataLength: 583,
+        "583": "InputMessagePredicateDataLength",
+        /**
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].data`
+        */
+        InputMessageData: 584,
+        "584": "InputMessageData",
+        /**
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicate`
+        */
+        InputMessagePredicate: 585,
+        "585": "InputMessagePredicate",
+        /**
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicateData`
+        */
+        InputMessagePredicateData: 586,
+        "586": "InputMessagePredicateData",
+        /**
+        *r" Set `$rA` to `Memory address of tx.inputs[$rB].predicateGasUsed`
+        */
+        InputMessagePredicateGasUsed: 587,
+        "587": "InputMessagePredicateGasUsed",
         /**
-        *r" Caller of this internal context is also expected to be internal,
-        *r" i.e. $fp->$fp must be non-zero.
+        *r" Set `$rA` to `tx.outputs[$rB].type`
         */
-        ExpectedNestedCaller: 46,
-        "46": "ExpectedNestedCaller",
+        OutputType: 768,
+        "768": "OutputType",
         /**
-        *r" During memory growth, the stack overlapped with the heap
+        *r" Set `$rA` to `Memory address of tx.outputs[$rB].to`
         */
-        MemoryGrowthOverlap: 47,
-        "47": "MemoryGrowthOverlap",
+        OutputCoinTo: 769,
+        "769": "OutputCoinTo",
         /**
-        *r" Attempting to read or write uninitialized memory.
-        *r" Also occurs when boundary crosses from stack to heap.
+        *r" Set `$rA` to `tx.outputs[$rB].amount`
         */
-        UninitalizedMemoryAccess: 48,
-        "48": "UninitalizedMemoryAccess",
+        OutputCoinAmount: 770,
+        "770": "OutputCoinAmount",
         /**
-        *r" Overriding consensus parameters is not allowed.
+        *r" Set `$rA` to `Memory address of tx.outputs[$rB].asset_id`
         */
-        OverridingConsensusParameters: 49,
-        "49": "OverridingConsensusParameters",
+        OutputCoinAssetId: 771,
+        "771": "OutputCoinAssetId",
         /**
-        *r" The storage doesn't know about the hash of the state transition bytecode.
+        *r" Set `$rA` to `tx.outputs[$rB].inputIndex`
         */
-        UnknownStateTransactionBytecodeRoot: 50,
-        "50": "UnknownStateTransactionBytecodeRoot",
+        OutputContractInputIndex: 772,
+        "772": "OutputContractInputIndex",
         /**
-        *r" Overriding the state transition bytecode is not allowed.
+        *r" Set `$rA` to `Memory address of tx.outputs[$rB].contractID`
         */
-        OverridingStateTransactionBytecode: 51,
-        "51": "OverridingStateTransactionBytecode",
+        OutputContractCreatedContractId: 775,
+        "775": "OutputContractCreatedContractId",
         /**
-        *r" The bytecode is already uploaded and cannot be uploaded again.
+        *r" Set `$rA` to `Memory address of tx.outputs[$rB].stateRoot`
         */
-        BytecodeAlreadyUploaded: 52,
-        "52": "BytecodeAlreadyUploaded",
+        OutputContractCreatedStateRoot: 776,
+        "776": "OutputContractCreatedStateRoot",
         /**
-        *r" The part of the bytecode is not sequentially connected to the previous parts.
+        *r" Set `$rA` to `tx.witnesses[$rB].dataLength`
         */
-        ThePartIsNotSequentiallyConnected: 53,
-        "53": "ThePartIsNotSequentiallyConnected"
-      });
-      var GMArgs = Object.freeze({
+        WitnessDataLength: 1024,
+        "1024": "WitnessDataLength",
         /**
-        *r" Get if caller is external.
+        *r" Set `$rA` to `Memory address of tx.witnesses[$rB].data`
         */
-        IsCallerExternal: 1,
-        "1": "IsCallerExternal",
+        WitnessData: 1025,
+        "1025": "WitnessData",
         /**
-        *r" Get caller's contract ID.
+        *r" Set `$rA` to `tx.policyTypes`
         */
-        GetCaller: 2,
-        "2": "GetCaller",
+        PolicyTypes: 1280,
+        "1280": "PolicyTypes",
         /**
-        *r" Get index of current predicate.
+        *r" Set `$rA` to `tx.policies[0x00].gasPrice`
         */
-        GetVerifyingPredicate: 3,
-        "3": "GetVerifyingPredicate",
+        PolicyTip: 1281,
+        "1281": "PolicyTip",
         /**
-        *r" Get the Chain ID this VM is operating within
+        *r" Set `$rA` to `tx.policies[count_ones(0b11 & tx.policyTypes) - 1].witnessLimit`
         */
-        GetChainId: 4,
-        "4": "GetChainId",
+        PolicyWitnessLimit: 1282,
+        "1282": "PolicyWitnessLimit",
         /**
-        *r" Get memory address where the transaction is located
+        *r" Set `$rA` to `tx.policies[count_ones(0b111 & tx.policyTypes) - 1].maturity`
         */
-        TxStart: 5,
-        "5": "TxStart",
+        PolicyMaturity: 1283,
+        "1283": "PolicyMaturity",
         /**
-        *r" Get memory address of base asset ID
+        *r" Set `$rA` to `tx.policies[count_ones(0b1111 & tx.policyTypes) - 1].maxFee`
         */
-        BaseAssetId: 6,
-        "6": "BaseAssetId"
+        PolicyMaxFee: 1284,
+        "1284": "PolicyMaxFee"
       });
       var MathOp = Object.freeze({
         /**
@@ -21601,43 +21661,6 @@ spurious results.`);
         SHR: 7,
         "7": "SHR"
       });
-      var CompareMode = Object.freeze({
-        /**
-        * Equality (`==`)
-        */
-        EQ: 0,
-        "0": "EQ",
-        /**
-        * Inequality (`!=`)
-        */
-        NE: 1,
-        "1": "NE",
-        /**
-        * Less than (`<`)
-        */
-        LT: 2,
-        "2": "LT",
-        /**
-        * Greater than (`>`)
-        */
-        GT: 3,
-        "3": "GT",
-        /**
-        * Less than or equals (`>=`)
-        */
-        LTE: 4,
-        "4": "LTE",
-        /**
-        * Greater than or equals (`>=`)
-        */
-        GTE: 5,
-        "5": "GTE",
-        /**
-        * Number of leading zeroes in lhs (`lzcnt`) (discards rhs)
-        */
-        LZC: 6,
-        "6": "LZC"
-      });
       var ADDFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
       }, unregister: () => {
       } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_add_free(ptr >>> 0));
@@ -21896,34 +21919,172 @@ spurious results.`);
           return Imm12.__wrap(ret3);
         }
       };
-      var BALFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+      var BALFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+      }, unregister: () => {
+      } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_bal_free(ptr >>> 0));
+      var BAL = class {
+        __destroy_into_raw() {
+          const ptr = this.__wbg_ptr;
+          this.__wbg_ptr = 0;
+          BALFinalization.unregister(this);
+          return ptr;
+        }
+        free() {
+          const ptr = this.__destroy_into_raw();
+          wasm$1.__wbg_bal_free(ptr);
+        }
+        /**
+        * Construct the instruction from its parts.
+        * @param {RegId} dst
+        * @param {RegId} asset_id_addr
+        * @param {RegId} contract_id_addr
+        */
+        constructor(dst, asset_id_addr, contract_id_addr) {
+          _assertClass(dst, RegId);
+          var ptr0 = dst.__destroy_into_raw();
+          _assertClass(asset_id_addr, RegId);
+          var ptr1 = asset_id_addr.__destroy_into_raw();
+          _assertClass(contract_id_addr, RegId);
+          var ptr2 = contract_id_addr.__destroy_into_raw();
+          const ret3 = wasm$1.add_new_typescript(ptr0, ptr1, ptr2);
+          this.__wbg_ptr = ret3 >>> 0;
+          return this;
+        }
+        /**
+        * Access the ID for register A.
+        * @returns {RegId}
+        */
+        ra() {
+          const ret3 = wasm$1.add_ra(this.__wbg_ptr);
+          return RegId.__wrap(ret3);
+        }
+        /**
+        * Access the ID for register B.
+        * @returns {RegId}
+        */
+        rb() {
+          const ret3 = wasm$1.add_rb(this.__wbg_ptr);
+          return RegId.__wrap(ret3);
+        }
+        /**
+        * Access the ID for register C.
+        * @returns {RegId}
+        */
+        rc() {
+          const ret3 = wasm$1.add_rc(this.__wbg_ptr);
+          return RegId.__wrap(ret3);
+        }
+      };
+      var BHEIFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+      }, unregister: () => {
+      } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_bhei_free(ptr >>> 0));
+      var BHEI = class {
+        __destroy_into_raw() {
+          const ptr = this.__wbg_ptr;
+          this.__wbg_ptr = 0;
+          BHEIFinalization.unregister(this);
+          return ptr;
+        }
+        free() {
+          const ptr = this.__destroy_into_raw();
+          wasm$1.__wbg_bhei_free(ptr);
+        }
+        /**
+        * Construct the instruction from its parts.
+        * @param {RegId} dst
+        */
+        constructor(dst) {
+          _assertClass(dst, RegId);
+          var ptr0 = dst.__destroy_into_raw();
+          const ret3 = wasm$1.aloc_new_typescript(ptr0);
+          this.__wbg_ptr = ret3 >>> 0;
+          return this;
+        }
+        /**
+        * Access the ID for register A.
+        * @returns {RegId}
+        */
+        ra() {
+          const ret3 = wasm$1.aloc_ra(this.__wbg_ptr);
+          return RegId.__wrap(ret3);
+        }
+      };
+      var BHSHFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+      }, unregister: () => {
+      } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_bhsh_free(ptr >>> 0));
+      var BHSH = class {
+        __destroy_into_raw() {
+          const ptr = this.__wbg_ptr;
+          this.__wbg_ptr = 0;
+          BHSHFinalization.unregister(this);
+          return ptr;
+        }
+        free() {
+          const ptr = this.__destroy_into_raw();
+          wasm$1.__wbg_bhsh_free(ptr);
+        }
+        /**
+        * Construct the instruction from its parts.
+        * @param {RegId} dst
+        * @param {RegId} heigth
+        */
+        constructor(dst, heigth) {
+          _assertClass(dst, RegId);
+          var ptr0 = dst.__destroy_into_raw();
+          _assertClass(heigth, RegId);
+          var ptr1 = heigth.__destroy_into_raw();
+          const ret3 = wasm$1.bhsh_new_typescript(ptr0, ptr1);
+          this.__wbg_ptr = ret3 >>> 0;
+          return this;
+        }
+        /**
+        * Access the ID for register A.
+        * @returns {RegId}
+        */
+        ra() {
+          const ret3 = wasm$1.add_ra(this.__wbg_ptr);
+          return RegId.__wrap(ret3);
+        }
+        /**
+        * Access the ID for register B.
+        * @returns {RegId}
+        */
+        rb() {
+          const ret3 = wasm$1.add_rb(this.__wbg_ptr);
+          return RegId.__wrap(ret3);
+        }
+      };
+      var BLDDFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
       }, unregister: () => {
-      } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_bal_free(ptr >>> 0));
-      var BAL = class {
+      } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_bldd_free(ptr >>> 0));
+      var BLDD = class {
         __destroy_into_raw() {
           const ptr = this.__wbg_ptr;
           this.__wbg_ptr = 0;
-          BALFinalization.unregister(this);
+          BLDDFinalization.unregister(this);
           return ptr;
         }
         free() {
           const ptr = this.__destroy_into_raw();
-          wasm$1.__wbg_bal_free(ptr);
+          wasm$1.__wbg_bldd_free(ptr);
         }
         /**
         * Construct the instruction from its parts.
-        * @param {RegId} dst
-        * @param {RegId} asset_id_addr
-        * @param {RegId} contract_id_addr
+        * @param {RegId} dst_ptr
+        * @param {RegId} blob_id_ptr
+        * @param {RegId} offset
+        * @param {RegId} len
         */
-        constructor(dst, asset_id_addr, contract_id_addr) {
-          _assertClass(dst, RegId);
-          var ptr0 = dst.__destroy_into_raw();
-          _assertClass(asset_id_addr, RegId);
-          var ptr1 = asset_id_addr.__destroy_into_raw();
-          _assertClass(contract_id_addr, RegId);
-          var ptr2 = contract_id_addr.__destroy_into_raw();
-          const ret3 = wasm$1.add_new_typescript(ptr0, ptr1, ptr2);
+        constructor(dst_ptr, blob_id_ptr, offset, len) {
+          _assertClass(dst_ptr, RegId);
+          var ptr0 = dst_ptr.__destroy_into_raw();
+          _assertClass(blob_id_ptr, RegId);
+          var ptr1 = blob_id_ptr.__destroy_into_raw();
+          _assertClass(offset, RegId);
+          var ptr2 = offset.__destroy_into_raw();
+          _assertClass(len, RegId);
+          var ptr3 = len.__destroy_into_raw();
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -21951,65 +22112,39 @@ spurious results.`);
           const ret3 = wasm$1.add_rc(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
-      };
-      var BHEIFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-      }, unregister: () => {
-      } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_bhei_free(ptr >>> 0));
-      var BHEI = class {
-        __destroy_into_raw() {
-          const ptr = this.__wbg_ptr;
-          this.__wbg_ptr = 0;
-          BHEIFinalization.unregister(this);
-          return ptr;
-        }
-        free() {
-          const ptr = this.__destroy_into_raw();
-          wasm$1.__wbg_bhei_free(ptr);
-        }
-        /**
-        * Construct the instruction from its parts.
-        * @param {RegId} dst
-        */
-        constructor(dst) {
-          _assertClass(dst, RegId);
-          var ptr0 = dst.__destroy_into_raw();
-          const ret3 = wasm$1.aloc_new_typescript(ptr0);
-          this.__wbg_ptr = ret3 >>> 0;
-          return this;
-        }
         /**
-        * Access the ID for register A.
+        * Access the ID for register D.
         * @returns {RegId}
         */
-        ra() {
-          const ret3 = wasm$1.aloc_ra(this.__wbg_ptr);
+        rd() {
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
-      var BHSHFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+      var BSIZFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
       }, unregister: () => {
-      } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_bhsh_free(ptr >>> 0));
-      var BHSH = class {
+      } } : new FinalizationRegistry((ptr) => wasm$1.__wbg_bsiz_free(ptr >>> 0));
+      var BSIZ = class {
         __destroy_into_raw() {
           const ptr = this.__wbg_ptr;
           this.__wbg_ptr = 0;
-          BHSHFinalization.unregister(this);
+          BSIZFinalization.unregister(this);
           return ptr;
         }
         free() {
           const ptr = this.__destroy_into_raw();
-          wasm$1.__wbg_bhsh_free(ptr);
+          wasm$1.__wbg_bsiz_free(ptr);
         }
         /**
         * Construct the instruction from its parts.
         * @param {RegId} dst
-        * @param {RegId} heigth
+        * @param {RegId} blob_id_ptr
         */
-        constructor(dst, heigth) {
+        constructor(dst, blob_id_ptr) {
           _assertClass(dst, RegId);
           var ptr0 = dst.__destroy_into_raw();
-          _assertClass(heigth, RegId);
-          var ptr1 = heigth.__destroy_into_raw();
+          _assertClass(blob_id_ptr, RegId);
+          var ptr1 = blob_id_ptr.__destroy_into_raw();
           const ret3 = wasm$1.bhsh_new_typescript(ptr0, ptr1);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
@@ -22106,7 +22241,7 @@ spurious results.`);
           var ptr2 = asset_id_addr.__destroy_into_raw();
           _assertClass(fwd_gas, RegId);
           var ptr3 = fwd_gas.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -22139,7 +22274,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -22207,7 +22342,7 @@ spurious results.`);
           var ptr2 = offset.__destroy_into_raw();
           _assertClass(len, RegId);
           var ptr3 = len.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -22240,7 +22375,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -22714,7 +22849,7 @@ spurious results.`);
           var ptr2 = c.__destroy_into_raw();
           _assertClass(d, RegId);
           var ptr3 = d.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -22747,7 +22882,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -22881,16 +23016,19 @@ spurious results.`);
         * Construct the instruction from its parts.
         * @param {RegId} pub_key_addr
         * @param {RegId} sig_addr
-        * @param {RegId} msg_hash_addr
+        * @param {RegId} msg_addr
+        * @param {RegId} msg_len
         */
-        constructor(pub_key_addr, sig_addr, msg_hash_addr) {
+        constructor(pub_key_addr, sig_addr, msg_addr, msg_len) {
           _assertClass(pub_key_addr, RegId);
           var ptr0 = pub_key_addr.__destroy_into_raw();
           _assertClass(sig_addr, RegId);
           var ptr1 = sig_addr.__destroy_into_raw();
-          _assertClass(msg_hash_addr, RegId);
-          var ptr2 = msg_hash_addr.__destroy_into_raw();
-          const ret3 = wasm$1.add_new_typescript(ptr0, ptr1, ptr2);
+          _assertClass(msg_addr, RegId);
+          var ptr2 = msg_addr.__destroy_into_raw();
+          _assertClass(msg_len, RegId);
+          var ptr3 = msg_len.__destroy_into_raw();
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -22918,6 +23056,14 @@ spurious results.`);
           const ret3 = wasm$1.add_rc(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
+        /**
+        * Access the ID for register D.
+        * @returns {RegId}
+        */
+        rd() {
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
+          return RegId.__wrap(ret3);
+        }
       };
       var EQFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
       }, unregister: () => {
@@ -23698,7 +23844,7 @@ spurious results.`);
           var ptr2 = dynamic.__destroy_into_raw();
           _assertClass(fixed, Imm06);
           var ptr3 = fixed.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -23765,7 +23911,7 @@ spurious results.`);
           var ptr2 = dynamic.__destroy_into_raw();
           _assertClass(fixed, Imm06);
           var ptr3 = fixed.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -24146,15 +24292,18 @@ spurious results.`);
         * @param {RegId} contract_id_addr
         * @param {RegId} offset
         * @param {RegId} len
+        * @param {Imm06} mode
         */
-        constructor(contract_id_addr, offset, len) {
+        constructor(contract_id_addr, offset, len, mode) {
           _assertClass(contract_id_addr, RegId);
           var ptr0 = contract_id_addr.__destroy_into_raw();
           _assertClass(offset, RegId);
           var ptr1 = offset.__destroy_into_raw();
           _assertClass(len, RegId);
           var ptr2 = len.__destroy_into_raw();
-          const ret3 = wasm$1.add_new_typescript(ptr0, ptr1, ptr2);
+          _assertClass(mode, Imm06);
+          var ptr3 = mode.__destroy_into_raw();
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -24182,6 +24331,14 @@ spurious results.`);
           const ret3 = wasm$1.add_rc(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
+        /**
+        * Access the 6-bit immediate value.
+        * @returns {Imm06}
+        */
+        imm06() {
+          const ret3 = wasm$1.jneb_imm06(this.__wbg_ptr);
+          return Imm06.__wrap(ret3);
+        }
       };
       var LOGFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
       }, unregister: () => {
@@ -24213,7 +24370,7 @@ spurious results.`);
           var ptr2 = c.__destroy_into_raw();
           _assertClass(d, RegId);
           var ptr3 = d.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -24246,7 +24403,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -24280,7 +24437,7 @@ spurious results.`);
           var ptr2 = addr.__destroy_into_raw();
           _assertClass(len, RegId);
           var ptr3 = len.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -24313,7 +24470,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -24661,7 +24818,7 @@ spurious results.`);
           var ptr2 = rhs_addr.__destroy_into_raw();
           _assertClass(len, RegId);
           var ptr3 = len.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -24694,7 +24851,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -24773,7 +24930,7 @@ spurious results.`);
           var ptr2 = mul_rhs.__destroy_into_raw();
           _assertClass(divisor, RegId);
           var ptr3 = divisor.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -24806,7 +24963,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -26297,7 +26454,7 @@ spurious results.`);
           var ptr2 = data_len.__destroy_into_raw();
           _assertClass(coins, RegId);
           var ptr3 = coins.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -26330,7 +26487,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -26532,7 +26689,7 @@ spurious results.`);
           var ptr2 = key_addr.__destroy_into_raw();
           _assertClass(lenq, RegId);
           var ptr3 = lenq.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -26565,7 +26722,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -26823,7 +26980,7 @@ spurious results.`);
           var ptr2 = src_addr.__destroy_into_raw();
           _assertClass(lenq, RegId);
           var ptr3 = lenq.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -26856,7 +27013,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -26991,7 +27148,7 @@ spurious results.`);
           var ptr2 = amount.__destroy_into_raw();
           _assertClass(asset_id_addr, RegId);
           var ptr3 = asset_id_addr.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -27024,7 +27181,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -27058,7 +27215,7 @@ spurious results.`);
           var ptr2 = add_rhs.__destroy_into_raw();
           _assertClass(modulo, RegId);
           var ptr3 = modulo.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -27091,7 +27248,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -27313,7 +27470,7 @@ spurious results.`);
           var ptr2 = mul_rhs.__destroy_into_raw();
           _assertClass(divisor, RegId);
           var ptr3 = divisor.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -27346,7 +27503,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -27474,7 +27631,7 @@ spurious results.`);
           var ptr2 = mul_rhs.__destroy_into_raw();
           _assertClass(modulo, RegId);
           var ptr3 = modulo.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -27507,7 +27664,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -27635,7 +27792,7 @@ spurious results.`);
           var ptr2 = add_rhs.__destroy_into_raw();
           _assertClass(modulo, RegId);
           var ptr3 = modulo.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -27668,7 +27825,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -27890,7 +28047,7 @@ spurious results.`);
           var ptr2 = mul_rhs.__destroy_into_raw();
           _assertClass(divisor, RegId);
           var ptr3 = divisor.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -27923,7 +28080,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -28051,7 +28208,7 @@ spurious results.`);
           var ptr2 = mul_rhs.__destroy_into_raw();
           _assertClass(modulo, RegId);
           var ptr3 = modulo.__destroy_into_raw();
-          const ret3 = wasm$1.call_new_typescript(ptr0, ptr1, ptr2, ptr3);
+          const ret3 = wasm$1.bldd_new_typescript(ptr0, ptr1, ptr2, ptr3);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
         }
@@ -28084,7 +28241,7 @@ spurious results.`);
         * @returns {RegId}
         */
         rd() {
-          const ret3 = wasm$1.call_rd(this.__wbg_ptr);
+          const ret3 = wasm$1.bldd_rd(this.__wbg_ptr);
           return RegId.__wrap(ret3);
         }
       };
@@ -28380,7 +28537,7 @@ spurious results.`);
         }
       }
       function wasm(imports) {
-        return _loadWasmModule(1, null, "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", imports);
+        return _loadWasmModule(1, null, "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", imports);
       }
       async function initWasm2() {
         return await __wbg_init(wasm());
@@ -28394,6 +28551,8 @@ spurious results.`);
       exports.BAL = BAL;
       exports.BHEI = BHEI;
       exports.BHSH = BHSH;
+      exports.BLDD = BLDD;
+      exports.BSIZ = BSIZ;
       exports.BURN = BURN;
       exports.CALL = CALL;
       exports.CB = CB;
@@ -28519,6 +28678,8 @@ spurious results.`);
       exports.bal = bal;
       exports.bhei = bhei;
       exports.bhsh = bhsh;
+      exports.bldd = bldd;
+      exports.bsiz = bsiz;
       exports.burn = burn;
       exports.call = call;
       exports.cb = cb;
@@ -28638,9 +28799,9 @@ spurious results.`);
   // ../versions/dist/index.mjs
   function getBuiltinVersions() {
     return {
-      FORC: "0.62.0",
-      FUEL_CORE: "0.31.0",
-      FUELS: "0.93.0"
+      FORC: "0.63.1",
+      FUEL_CORE: "0.33.0",
+      FUELS: "0.94.1"
     };
   }
   function parseVersion(version) {
@@ -28711,6 +28872,10 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["INVALID_DATA"] = "invalid-data";
     ErrorCode2["FUNCTION_NOT_FOUND"] = "function-not-found";
     ErrorCode2["UNSUPPORTED_ENCODING_VERSION"] = "unsupported-encoding-version";
+    ErrorCode2["TIMEOUT_EXCEEDED"] = "timeout-exceeded";
+    ErrorCode2["CONFIG_FILE_NOT_FOUND"] = "config-file-not-found";
+    ErrorCode2["CONFIG_FILE_ALREADY_EXISTS"] = "config-file-already-exists";
+    ErrorCode2["WORKSPACE_NOT_DETECTED"] = "workspace-not-detected";
     ErrorCode2["INVALID_BECH32_ADDRESS"] = "invalid-bech32-address";
     ErrorCode2["INVALID_EVM_ADDRESS"] = "invalid-evm-address";
     ErrorCode2["INVALID_B256_ADDRESS"] = "invalid-b256-address";
@@ -28736,6 +28901,7 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["MISSING_REQUIRED_PARAMETER"] = "missing-required-parameter";
     ErrorCode2["INVALID_REQUEST"] = "invalid-request";
     ErrorCode2["INVALID_TRANSFER_AMOUNT"] = "invalid-transfer-amount";
+    ErrorCode2["NOT_ENOUGH_FUNDS"] = "not-enough-funds";
     ErrorCode2["INVALID_CREDENTIALS"] = "invalid-credentials";
     ErrorCode2["HASHER_LOCKED"] = "hasher-locked";
     ErrorCode2["GAS_PRICE_TOO_LOW"] = "gas-price-too-low";
@@ -28753,6 +28919,10 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["DUPLICATED_POLICY"] = "duplicated-policy";
     ErrorCode2["TRANSACTION_SQUEEZED_OUT"] = "transaction-squeezed-out";
     ErrorCode2["CONTRACT_SIZE_EXCEEDS_LIMIT"] = "contract-size-exceeds-limit";
+    ErrorCode2["INVALID_CHUNK_SIZE_MULTIPLIER"] = "invalid-chunk-size-multiplier";
+    ErrorCode2["MAX_INPUTS_EXCEEDED"] = "max-inputs-exceeded";
+    ErrorCode2["FUNDS_TOO_LOW"] = "funds-too-low";
+    ErrorCode2["MAX_OUTPUTS_EXCEEDED"] = "max-outputs-exceeded";
     ErrorCode2["INVALID_RECEIPT_TYPE"] = "invalid-receipt-type";
     ErrorCode2["INVALID_WORD_LIST"] = "invalid-word-list";
     ErrorCode2["INVALID_MNEMONIC"] = "invalid-mnemonic";
@@ -29335,6 +29505,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
   function toUtf8String(bytes3) {
     return helper(getUtf8CodePoints(bytes3));
   }
+  function assertUnreachable(_x) {
+    throw new Error("Didn't expect to get here");
+  }
 
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/_assert.js
   function number(n) {
@@ -30242,6 +30415,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
   var import_crypto3 = __toESM(__require("crypto"), 1);
   var import_crypto4 = __toESM(__require("crypto"), 1);
   var import_crypto5 = __require("crypto");
+  var import_crypto6 = __require("crypto");
   var scrypt2 = (params) => {
     const { password, salt, n, p, r, dklen } = params;
     const derivedKey = scrypt(password, salt, { N: n, r, p, dkLen: dklen });
@@ -30355,6 +30529,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     computeHMAC = func;
   };
   Object.freeze(computeHmac);
+  var randomUUID = () => (0, import_crypto6.randomUUID)();
   var api = {
     bufferFromString,
     stringFromBuffer,
@@ -30368,7 +30543,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
     encryptJsonWalletData,
     computeHmac,
     pbkdf2: pbkdf22,
-    ripemd160: ripemd1602
+    ripemd160: ripemd1602,
+    randomUUID
   };
   var node_default = api;
   var {
@@ -30384,7 +30560,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
     encryptJsonWalletData: encryptJsonWalletData2,
     computeHmac: computeHmac2,
     pbkdf2: pbkdf222,
-    ripemd160: ripemd16022
+    ripemd160: ripemd16022,
+    randomUUID: randomUUID2
   } = node_default;
 
   // ../hasher/dist/index.mjs
@@ -30431,18 +30608,21 @@ If you are attempting to transform a hex value, please make sure it is being pas
   var RAW_SLICE_CODER_TYPE = "raw untyped slice";
   var BOOL_CODER_TYPE = "bool";
   var B256_CODER_TYPE = "b256";
-  var B512_CODER_TYPE = "struct B512";
-  var OPTION_CODER_TYPE = "enum Option";
-  var VEC_CODER_TYPE = "struct Vec";
-  var BYTES_CODER_TYPE = "struct Bytes";
-  var STD_STRING_CODER_TYPE = "struct String";
+  var B512_CODER_TYPE = "struct std::b512::B512";
+  var OPTION_CODER_TYPE = "enum std::option::Option";
+  var VEC_CODER_TYPE = "struct std::vec::Vec";
+  var BYTES_CODER_TYPE = "struct std::bytes::Bytes";
+  var STD_STRING_CODER_TYPE = "struct std::string::String";
   var STR_SLICE_CODER_TYPE = "str";
+  var VOID_TYPE = "()";
+  var optionRegEx = /^enum (std::option::)?Option$/m;
   var stringRegEx = /str\[(?<length>[0-9]+)\]/;
   var arrayRegEx = /\[(?<item>[\w\s\\[\]]+);\s*(?<length>[0-9]+)\]/;
-  var structRegEx = /^struct (?<name>\w+)$/;
-  var enumRegEx = /^enum (?<name>\w+)$/;
+  var structRegEx = /struct.+/;
+  var enumRegEx = /^enum.+$/;
   var tupleRegEx = /^\((?<items>.*)\)$/;
-  var genericRegEx = /^generic (?<name>\w+)$/;
+  var genericRegEx = /^generic.+$/;
+  var fullNameRegExMatch = /([^\s]+)$/m;
   var ENCODING_V1 = "1";
   var WORD_SIZE = 8;
   var BYTES_32 = 32;
@@ -30696,16 +30876,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
       this.coders = coders;
       this.#caseIndexCoder = caseIndexCoder;
       this.#encodedValueSize = encodedValueSize;
-      this.#shouldValidateLength = !(this.type === OPTION_CODER_TYPE || hasNestedOption(coders));
+      this.#shouldValidateLength = !(optionRegEx.test(this.type) || hasNestedOption(coders));
     }
-    // We parse a native enum as an empty tuple, so we are looking for a tuple with no child coders.
-    // The '()' is enough but the child coders is a stricter check.
+    // Checks that we're handling a native enum that is of type void.
     #isNativeEnum(coder) {
-      if (this.type !== OPTION_CODER_TYPE && coder.type === "()") {
-        const tupleCoder = coder;
-        return tupleCoder.coders.length === 0;
-      }
-      return false;
+      return this.type !== OPTION_CODER_TYPE && coder.type === VOID_TYPE;
     }
     #encodeNativeEnum(value) {
       const valueCoder = this.coders[value];
@@ -31060,16 +31235,6 @@ If you are attempting to transform a hex value, please make sure it is being pas
         );
     }
   };
-  var findFunctionByName = (abi, name) => {
-    const fn = abi.functions.find((f2) => f2.name === name);
-    if (!fn) {
-      throw new FuelError(
-        ErrorCode.FUNCTION_NOT_FOUND,
-        `Function with name '${name}' doesn't exist in the ABI`
-      );
-    }
-    return fn;
-  };
   var findTypeById = (abi, typeId) => {
     const type3 = abi.types.find((t) => t.typeId === typeId);
     if (!type3) {
@@ -31080,7 +31245,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
     return type3;
   };
-  var findNonEmptyInputs = (abi, inputs) => inputs.filter((input) => findTypeById(abi, input.type).type !== "()");
+  var findNonVoidInputs = (abi, inputs) => inputs.filter((input) => findTypeById(abi, input.type).type !== VOID_TYPE);
   var findVectorBufferArgument = (components) => {
     const bufferComponent = components.find((c) => c.name === "buf");
     const bufferTypeArgument = bufferComponent?.originalTypeArguments?.[0];
@@ -31231,6 +31396,17 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return `${typeArgumentsSignature}${componentsSignature}`;
     }
   };
+  var VoidCoder = class extends Coder {
+    constructor() {
+      super("void", VOID_TYPE, 0);
+    }
+    encode(_value) {
+      return new Uint8Array([]);
+    }
+    decode(_data, offset) {
+      return [void 0, offset];
+    }
+  };
   function getCoders(components, options) {
     const { getCoder: getCoder2 } = options;
     return components.reduce((obj, component) => {
@@ -31264,6 +31440,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
         return new StdStringCoder();
       case STR_SLICE_CODER_TYPE:
         return new StrSliceCoder();
+      case VOID_TYPE:
+        return new VoidCoder();
       default:
         break;
     }
@@ -31292,19 +31470,20 @@ If you are attempting to transform a hex value, please make sure it is being pas
       const itemCoder = getCoder(argType, { encoding: ENCODING_V1 });
       return new VecCoder(itemCoder);
     }
-    const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
-    if (structMatch) {
+    const coderName = resolvedAbiType.type.match(fullNameRegExMatch)?.[0];
+    const structMatch = structRegEx.test(resolvedAbiType.type);
+    if (structMatch && coderName) {
       const coders = getCoders(components, { getCoder });
-      return new StructCoder(structMatch.name, coders);
+      return new StructCoder(coderName, coders);
     }
-    const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
-    if (enumMatch) {
+    const enumMatch = enumRegEx.test(resolvedAbiType.type);
+    if (enumMatch && coderName) {
       const coders = getCoders(components, { getCoder });
       const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
       if (isOptionEnum) {
-        return new OptionCoder(enumMatch.name, coders);
+        return new OptionCoder(coderName, coders);
       }
-      return new EnumCoder(enumMatch.name, coders);
+      return new EnumCoder(coderName, coders);
     }
     const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
     if (tupleMatch) {
@@ -31341,6 +31520,24 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return this.getCoder(abi, argument, options).decode(data, offset);
     }
   };
+  var getFunctionInputs = (params) => {
+    const { jsonAbi, inputs } = params;
+    let isMandatory = false;
+    return inputs.reduceRight((result, input) => {
+      const type3 = findTypeById(jsonAbi, input.type);
+      isMandatory = isMandatory || type3.type !== VOID_TYPE && !optionRegEx.test(type3.type);
+      return [{ ...input, isOptional: !isMandatory }, ...result];
+    }, []);
+  };
+  var padValuesWithUndefined = (values, inputs) => {
+    if (values.length >= inputs.length) {
+      return values;
+    }
+    const paddedValues = values.slice();
+    paddedValues.length = inputs.length;
+    paddedValues.fill(void 0, values.length);
+    return paddedValues;
+  };
   var FunctionFragment = class {
     signature;
     selector;
@@ -31349,14 +31546,16 @@ If you are attempting to transform a hex value, please make sure it is being pas
     name;
     jsonFn;
     attributes;
-    jsonAbi;
-    constructor(jsonAbi, name) {
-      this.jsonAbi = jsonAbi;
-      this.jsonFn = findFunctionByName(this.jsonAbi, name);
-      this.name = name;
-      this.signature = FunctionFragment.getSignature(this.jsonAbi, this.jsonFn);
+    jsonAbiOld;
+    jsonFnOld;
+    constructor(jsonAbi, fn) {
+      this.jsonFn = fn;
+      this.jsonAbiOld = jsonAbi;
+      this.jsonFnOld = jsonAbi.functions.find((f2) => f2.name === fn.name);
+      this.name = fn.name;
+      this.signature = FunctionFragment.getSignature(this.jsonAbiOld, this.jsonFnOld);
       this.selector = FunctionFragment.getFunctionSelector(this.signature);
-      this.selectorBytes = new StdStringCoder().encode(name);
+      this.selectorBytes = new StdStringCoder().encode(this.name);
       this.encoding = getEncodingVersion(jsonAbi.encoding);
       this.attributes = this.jsonFn.attributes ?? [];
     }
@@ -31371,41 +31570,26 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return bn(hashedFunctionSignature.slice(0, 10)).toHex(8);
     }
     encodeArguments(values) {
-      FunctionFragment.verifyArgsAndInputsAlign(values, this.jsonFn.inputs, this.jsonAbi);
-      const shallowCopyValues = values.slice();
-      const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
-      if (Array.isArray(values) && nonEmptyInputs.length !== values.length) {
-        shallowCopyValues.length = this.jsonFn.inputs.length;
-        shallowCopyValues.fill(void 0, values.length);
-      }
-      const coders = nonEmptyInputs.map(
-        (t) => AbiCoder.getCoder(this.jsonAbi, t, {
+      const inputs = getFunctionInputs({ jsonAbi: this.jsonAbiOld, inputs: this.jsonFnOld.inputs });
+      const mandatoryInputLength = inputs.filter((i) => !i.isOptional).length;
+      if (values.length < mandatoryInputLength) {
+        throw new FuelError(
+          ErrorCode.ABI_TYPES_AND_VALUES_MISMATCH,
+          `Invalid number of arguments. Expected a minimum of ${mandatoryInputLength} arguments, received ${values.length}`
+        );
+      }
+      const coders = this.jsonFnOld.inputs.map(
+        (t) => AbiCoder.getCoder(this.jsonAbiOld, t, {
           encoding: this.encoding
         })
       );
-      return new TupleCoder(coders).encode(shallowCopyValues);
-    }
-    static verifyArgsAndInputsAlign(args, inputs, abi) {
-      if (args.length === inputs.length) {
-        return;
-      }
-      const inputTypes = inputs.map((input) => findTypeById(abi, input.type));
-      const optionalInputs = inputTypes.filter(
-        (x) => x.type === OPTION_CODER_TYPE || x.type === "()"
-      );
-      if (optionalInputs.length === inputTypes.length) {
-        return;
-      }
-      if (inputTypes.length - optionalInputs.length === args.length) {
-        return;
-      }
-      const errorMsg = `Mismatch between provided arguments and expected ABI inputs. Provided ${args.length} arguments, but expected ${inputs.length - optionalInputs.length} (excluding ${optionalInputs.length} optional inputs).`;
-      throw new FuelError(ErrorCode.ABI_TYPES_AND_VALUES_MISMATCH, errorMsg);
+      const argumentValues = padValuesWithUndefined(values, this.jsonFn.inputs);
+      return new TupleCoder(coders).encode(argumentValues);
     }
     decodeArguments(data) {
       const bytes3 = arrayify(data);
-      const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
-      if (nonEmptyInputs.length === 0) {
+      const nonVoidInputs = findNonVoidInputs(this.jsonAbiOld, this.jsonFnOld.inputs);
+      if (nonVoidInputs.length === 0) {
         if (bytes3.length === 0) {
           return void 0;
         }
@@ -31414,20 +31598,20 @@ If you are attempting to transform a hex value, please make sure it is being pas
           `Types/values length mismatch during decode. ${JSON.stringify({
             count: {
               types: this.jsonFn.inputs.length,
-              nonEmptyInputs: nonEmptyInputs.length,
+              nonVoidInputs: nonVoidInputs.length,
               values: bytes3.length
             },
             value: {
               args: this.jsonFn.inputs,
-              nonEmptyInputs,
+              nonVoidInputs,
               values: bytes3
             }
           })}`
         );
       }
-      const result = nonEmptyInputs.reduce(
+      const result = this.jsonFnOld.inputs.reduce(
         (obj, input) => {
-          const coder = AbiCoder.getCoder(this.jsonAbi, input, { encoding: this.encoding });
+          const coder = AbiCoder.getCoder(this.jsonAbiOld, input, { encoding: this.encoding });
           const [decodedValue, decodedValueByteSize] = coder.decode(bytes3, obj.offset);
           return {
             decoded: [...obj.decoded, decodedValue],
@@ -31439,12 +31623,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return result.decoded;
     }
     decodeOutput(data) {
-      const outputAbiType = findTypeById(this.jsonAbi, this.jsonFn.output.type);
-      if (outputAbiType.type === "()") {
-        return [void 0, 0];
-      }
       const bytes3 = arrayify(data);
-      const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output, {
+      const coder = AbiCoder.getCoder(this.jsonAbiOld, this.jsonFnOld.output, {
         encoding: this.encoding
       });
       return coder.decode(bytes3, 0);
@@ -31456,19 +31636,119 @@ If you are attempting to transform a hex value, please make sure it is being pas
      */
     isReadOnly() {
       const storageAttribute = this.attributes.find((attr) => attr.name === "storage");
-      return !storageAttribute?.arguments.includes("write");
+      return !storageAttribute?.arguments?.includes("write");
     }
   };
+  var findTypeByConcreteId = (types, id) => types.find((x) => x.concreteTypeId === id);
+  var findConcreteTypeById = (abi, id) => abi.concreteTypes.find((x) => x.concreteTypeId === id);
+  function finsertTypeIdByConcreteTypeId(abi, types, id) {
+    const concreteType = findConcreteTypeById(abi, id);
+    if (concreteType.metadataTypeId !== void 0) {
+      return concreteType.metadataTypeId;
+    }
+    const type3 = findTypeByConcreteId(types, id);
+    if (type3) {
+      return type3.typeId;
+    }
+    types.push({
+      typeId: types.length,
+      type: concreteType.type,
+      components: parseComponents(concreteType.components),
+      concreteTypeId: id,
+      typeParameters: concreteType.typeParameters ?? null,
+      originalConcreteTypeId: concreteType?.concreteTypeId
+    });
+    return types.length - 1;
+  }
+  function parseFunctionTypeArguments(abi, types, concreteType) {
+    return concreteType.typeArguments?.map((cTypeId) => {
+      const self = findConcreteTypeById(abi, cTypeId);
+      const type3 = !isNaN(cTypeId) ? cTypeId : finsertTypeIdByConcreteTypeId(abi, types, cTypeId);
+      return {
+        name: "",
+        type: type3,
+        // originalTypeId: cTypeId,
+        typeArguments: parseFunctionTypeArguments(abi, types, self)
+      };
+    }) ?? null;
+  }
+  function parseConcreteType(abi, types, concreteTypeId, name) {
+    const type3 = finsertTypeIdByConcreteTypeId(abi, types, concreteTypeId);
+    const concrete = findConcreteTypeById(abi, concreteTypeId);
+    return {
+      name: name ?? "",
+      type: type3,
+      // concreteTypeId,
+      typeArguments: parseFunctionTypeArguments(abi, types, concrete)
+    };
+  }
+  function parseComponents(abi, types, components) {
+    return components?.map((component) => {
+      const { typeId, name, typeArguments } = component;
+      const type3 = !isNaN(typeId) ? typeId : finsertTypeIdByConcreteTypeId(abi, types, typeId);
+      return {
+        name,
+        type: type3,
+        // originalTypeId: typeId,
+        typeArguments: parseComponents(abi, types, typeArguments)
+      };
+    }) ?? null;
+  }
+  function transpileAbi(abi) {
+    if (!abi.specVersion) {
+      return abi;
+    }
+    const types = [];
+    abi.metadataTypes.forEach((m) => {
+      const t = {
+        typeId: m.metadataTypeId,
+        type: m.type,
+        components: m.components ?? (m.type === "()" ? [] : null),
+        typeParameters: m.typeParameters ?? null
+      };
+      types.push(t);
+    });
+    types.forEach((t) => {
+      t.components = parseComponents(abi, types, t.components);
+    });
+    const functions = abi.functions.map((fn) => {
+      const inputs = fn.inputs.map(
+        ({ concreteTypeId, name }) => parseConcreteType(abi, types, concreteTypeId, name)
+      );
+      const output3 = parseConcreteType(abi, types, fn.output, "");
+      return { ...fn, inputs, output: output3 };
+    });
+    const configurables = abi.configurables.map((conf) => ({
+      name: conf.name,
+      configurableType: parseConcreteType(abi, types, conf.concreteTypeId),
+      offset: conf.offset
+    }));
+    const loggedTypes = abi.loggedTypes.map((log) => ({
+      logId: log.logId,
+      loggedType: parseConcreteType(abi, types, log.concreteTypeId)
+    }));
+    const transpiled = {
+      encoding: abi.encodingVersion,
+      types,
+      functions,
+      loggedTypes,
+      messagesTypes: abi.messagesTypes,
+      configurables
+    };
+    return transpiled;
+  }
   var Interface = class {
     functions;
     configurables;
     jsonAbi;
     encoding;
+    jsonAbiOld;
     constructor(jsonAbi) {
       this.jsonAbi = jsonAbi;
-      this.encoding = getEncodingVersion(jsonAbi.encoding);
+      this.encoding = getEncodingVersion(jsonAbi.encodingVersion);
+      this.jsonAbiOld = transpileAbi(jsonAbi);
       this.functions = Object.fromEntries(
-        this.jsonAbi.functions.map((x) => [x.name, new FunctionFragment(this.jsonAbi, x.name)])
+        this.jsonAbi.functions.map((fn) => [fn.name, new FunctionFragment(this.jsonAbiOld, fn)])
       );
       this.configurables = Object.fromEntries(this.jsonAbi.configurables.map((x) => [x.name, x]));
     }
@@ -31494,31 +31774,48 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return fragment.decodeOutput(data);
     }
     decodeLog(data, logId) {
-      const loggedType = this.jsonAbi.loggedTypes.find((type3) => type3.logId === logId);
+      const loggedType = this.jsonAbiOld.loggedTypes.find((type3) => type3.logId === logId);
       if (!loggedType) {
         throw new FuelError(
           ErrorCode.LOG_TYPE_NOT_FOUND,
           `Log type with logId '${logId}' doesn't exist in the ABI.`
         );
       }
-      return AbiCoder.decode(this.jsonAbi, loggedType.loggedType, arrayify(data), 0, {
+      return AbiCoder.decode(this.jsonAbiOld, loggedType.loggedType, arrayify(data), 0, {
         encoding: this.encoding
       });
     }
     encodeConfigurable(name, value) {
-      const configurable = this.jsonAbi.configurables.find((c) => c.name === name);
+      const configurable = this.jsonAbiOld.configurables.find((c) => c.name === name);
       if (!configurable) {
         throw new FuelError(
           ErrorCode.CONFIGURABLE_NOT_FOUND,
           `A configurable with the '${name}' was not found in the ABI.`
         );
       }
-      return AbiCoder.encode(this.jsonAbi, configurable.configurableType, value, {
+      return AbiCoder.encode(this.jsonAbiOld, configurable.configurableType, value, {
+        encoding: this.encoding
+      });
+    }
+    encodeType(concreteTypeId, value) {
+      const typeArg = parseConcreteType(
+        this.jsonAbi,
+        this.jsonAbiOld.types,
+        concreteTypeId,
+        ""
+      );
+      return AbiCoder.encode(this.jsonAbiOld, typeArg, value, {
         encoding: this.encoding
       });
     }
-    getTypeById(typeId) {
-      return findTypeById(this.jsonAbi, typeId);
+    decodeType(concreteTypeId, data) {
+      const typeArg = parseConcreteType(
+        this.jsonAbi,
+        this.jsonAbiOld.types,
+        concreteTypeId,
+        ""
+      );
+      return AbiCoder.decode(this.jsonAbiOld, typeArg, data, 0, { encoding: this.encoding });
     }
   };
 
@@ -32017,6 +32314,19 @@ If you are attempting to transform a hex value, please make sure it is being pas
         txIndex: new NumberCoder("u16", { padToWordSize: true })
       });
     }
+    static decodeFromGqlScalar(value) {
+      if (value.length !== 12) {
+        throw new FuelError(
+          ErrorCode.DECODE_ERROR,
+          `Invalid TxPointer scalar string length ${value.length}. It must have length 12.`
+        );
+      }
+      const [blockHeight, txIndex] = [value.substring(0, 8), value.substring(8)];
+      return {
+        blockHeight: parseInt(blockHeight, 16),
+        txIndex: parseInt(txIndex, 16)
+      };
+    }
   };
   var InputType = /* @__PURE__ */ ((InputType2) => {
     InputType2[InputType2["Coin"] = 0] = "Coin";
@@ -32850,6 +33160,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     TransactionType2[TransactionType2["Mint"] = 2] = "Mint";
     TransactionType2[TransactionType2["Upgrade"] = 3] = "Upgrade";
     TransactionType2[TransactionType2["Upload"] = 4] = "Upload";
+    TransactionType2[TransactionType2["Blob"] = 5] = "Blob";
     return TransactionType2;
   })(TransactionType || {});
   var TransactionScriptCoder = class extends Coder {
@@ -33174,6 +33485,65 @@ If you are attempting to transform a hex value, please make sure it is being pas
       ];
     }
   };
+  var TransactionBlobCoder = class extends Coder {
+    constructor() {
+      super("TransactionBlob", "struct TransactionBlob", 0);
+    }
+    encode(value) {
+      const parts = [];
+      parts.push(new B256Coder().encode(value.blobId));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessIndex));
+      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.policyTypes));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.inputsCount));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputsCount));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessesCount));
+      parts.push(new PoliciesCoder().encode(value.policies));
+      parts.push(new ArrayCoder(new InputCoder(), value.inputsCount).encode(value.inputs));
+      parts.push(new ArrayCoder(new OutputCoder(), value.outputsCount).encode(value.outputs));
+      parts.push(new ArrayCoder(new WitnessCoder(), value.witnessesCount).encode(value.witnesses));
+      return concat(parts);
+    }
+    decode(data, offset) {
+      let decoded;
+      let o = offset;
+      [decoded, o] = new B256Coder().decode(data, o);
+      const blobId = decoded;
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      const witnessIndex = decoded;
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
+      const policyTypes = decoded;
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      const inputsCount = decoded;
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      const outputsCount = decoded;
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      const witnessesCount = decoded;
+      [decoded, o] = new PoliciesCoder().decode(data, o, policyTypes);
+      const policies = decoded;
+      [decoded, o] = new ArrayCoder(new InputCoder(), inputsCount).decode(data, o);
+      const inputs = decoded;
+      [decoded, o] = new ArrayCoder(new OutputCoder(), outputsCount).decode(data, o);
+      const outputs = decoded;
+      [decoded, o] = new ArrayCoder(new WitnessCoder(), witnessesCount).decode(data, o);
+      const witnesses = decoded;
+      return [
+        {
+          type: 5,
+          blobId,
+          witnessIndex,
+          policyTypes,
+          inputsCount,
+          outputsCount,
+          witnessesCount,
+          policies,
+          inputs,
+          outputs,
+          witnesses
+        },
+        o
+      ];
+    }
+  };
   var TransactionCoder = class extends Coder {
     constructor() {
       super("Transaction", "struct Transaction", 0);
@@ -33211,6 +33581,10 @@ If you are attempting to transform a hex value, please make sure it is being pas
           );
           break;
         }
+        case 5: {
+          parts.push(new TransactionBlobCoder().encode(value));
+          break;
+        }
         default: {
           throw new FuelError(
             ErrorCode.UNSUPPORTED_TRANSACTION_TYPE,
@@ -33246,6 +33620,10 @@ If you are attempting to transform a hex value, please make sure it is being pas
           [decoded, o] = new TransactionUploadCoder().decode(data, o);
           return [decoded, o];
         }
+        case 5: {
+          [decoded, o] = new TransactionBlobCoder().decode(data, o);
+          return [decoded, o];
+        }
         default: {
           throw new FuelError(
             ErrorCode.UNSUPPORTED_TRANSACTION_TYPE,
@@ -36662,14 +37040,6 @@ spurious results.`);
   var lib_default2 = gql;
 
   // src/providers/__generated__/operations.ts
-  var TransactionStatusSubscriptionFragmentDoc = lib_default2`
-    fragment transactionStatusSubscriptionFragment on TransactionStatus {
-  type: __typename
-  ... on SqueezedOutStatus {
-    reason
-  }
-}
-    `;
   var SubmittedStatusFragmentDoc = lib_default2`
     fragment SubmittedStatusFragment on SubmittedStatus {
   type: __typename
@@ -36726,6 +37096,47 @@ spurious results.`);
   totalFee
 }
     ${ReceiptFragmentDoc}`;
+  var MalleableTransactionFieldsFragmentDoc = lib_default2`
+    fragment malleableTransactionFieldsFragment on Transaction {
+  receiptsRoot
+  inputs {
+    type: __typename
+    ... on InputCoin {
+      txPointer
+    }
+    ... on InputContract {
+      txPointer
+    }
+  }
+  outputs {
+    type: __typename
+    ... on CoinOutput {
+      to
+      amount
+      assetId
+    }
+    ... on ContractOutput {
+      inputIndex
+      balanceRoot
+      stateRoot
+    }
+    ... on ChangeOutput {
+      to
+      amount
+      assetId
+    }
+    ... on VariableOutput {
+      to
+      amount
+      assetId
+    }
+    ... on ContractCreated {
+      contract
+      stateRoot
+    }
+  }
+}
+    `;
   var FailureStatusFragmentDoc = lib_default2`
     fragment FailureStatusFragment on FailureStatus {
   type: __typename
@@ -36740,13 +37151,39 @@ spurious results.`);
     ...receiptFragment
   }
 }
-    ${ReceiptFragmentDoc}`;
-  var SqueezedOutStatusFragmentDoc = lib_default2`
-    fragment SqueezedOutStatusFragment on SqueezedOutStatus {
-  type: __typename
-  reason
-}
-    `;
+    ${ReceiptFragmentDoc}`;
+  var SqueezedOutStatusFragmentDoc = lib_default2`
+    fragment SqueezedOutStatusFragment on SqueezedOutStatus {
+  type: __typename
+  reason
+}
+    `;
+  var TransactionStatusSubscriptionFragmentDoc = lib_default2`
+    fragment transactionStatusSubscriptionFragment on TransactionStatus {
+  ... on SubmittedStatus {
+    ...SubmittedStatusFragment
+  }
+  ... on SuccessStatus {
+    ...SuccessStatusFragment
+    transaction {
+      ...malleableTransactionFieldsFragment
+    }
+  }
+  ... on FailureStatus {
+    ...FailureStatusFragment
+    transaction {
+      ...malleableTransactionFieldsFragment
+    }
+  }
+  ... on SqueezedOutStatus {
+    ...SqueezedOutStatusFragment
+  }
+}
+    ${SubmittedStatusFragmentDoc}
+${SuccessStatusFragmentDoc}
+${MalleableTransactionFieldsFragmentDoc}
+${FailureStatusFragmentDoc}
+${SqueezedOutStatusFragmentDoc}`;
   var TransactionStatusFragmentDoc = lib_default2`
     fragment transactionStatusFragment on TransactionStatus {
   ... on SubmittedStatus {
@@ -37087,6 +37524,12 @@ ${ReceiptFragmentDoc}`;
   alocDependentCost {
     ...DependentCostFragment
   }
+  bldd {
+    ...DependentCostFragment
+  }
+  bsiz {
+    ...DependentCostFragment
+  }
   cfe {
     ...DependentCostFragment
   }
@@ -37105,6 +37548,9 @@ ${ReceiptFragmentDoc}`;
   csiz {
     ...DependentCostFragment
   }
+  ed19DependentCost {
+    ...DependentCostFragment
+  }
   k256 {
     ...DependentCostFragment
   }
@@ -37634,12 +38080,11 @@ ${MessageFragmentDoc}`;
 
   // src/providers/fuel-graphql-subscriber.ts
   var _FuelGraphqlSubscriber = class {
-    constructor(options) {
-      this.options = options;
+    constructor(stream) {
+      this.stream = stream;
     }
-    stream;
-    async setStream() {
-      const { url, query, variables, fetchFn } = this.options;
+    static async create(options) {
+      const { url, query, variables, fetchFn } = options;
       const response = await fetchFn(`${url}-sub`, {
         method: "POST",
         body: JSON.stringify({
@@ -37651,14 +38096,11 @@ ${MessageFragmentDoc}`;
           Accept: "text/event-stream"
         }
       });
-      this.stream = response.body.getReader();
+      return new _FuelGraphqlSubscriber(response.body.getReader());
     }
     events = [];
     parsingLeftover = "";
     async next() {
-      if (!this.stream) {
-        await this.setStream();
-      }
       while (true) {
         if (this.events.length > 0) {
           const { data, errors } = this.events.shift();
@@ -37709,60 +38151,63 @@ ${MessageFragmentDoc}`;
   var FuelGraphqlSubscriber = _FuelGraphqlSubscriber;
   __publicField(FuelGraphqlSubscriber, "textDecoder", new TextDecoder());
 
-  // src/providers/memory-cache.ts
-  var cache = {};
-  var DEFAULT_TTL_IN_MS = 30 * 1e3;
-  var MemoryCache = class {
+  // src/providers/resource-cache.ts
+  var cache = /* @__PURE__ */ new Map();
+  var ResourceCache = class {
     ttl;
-    constructor(ttlInMs = DEFAULT_TTL_IN_MS) {
-      this.ttl = ttlInMs;
-      if (typeof ttlInMs !== "number" || this.ttl <= 0) {
+    constructor(ttl) {
+      this.ttl = ttl;
+      if (typeof ttl !== "number" || this.ttl <= 0) {
         throw new FuelError(
           ErrorCode.INVALID_TTL,
           `Invalid TTL: ${this.ttl}. Use a value greater than zero.`
         );
       }
     }
-    get(value, isAutoExpiring = true) {
-      const key = hexlify(value);
-      if (cache[key]) {
-        if (!isAutoExpiring || cache[key].expires > Date.now()) {
-          return cache[key].value;
-        }
-        this.del(value);
-      }
-      return void 0;
-    }
-    set(value) {
-      const expiresAt = Date.now() + this.ttl;
-      const key = hexlify(value);
-      cache[key] = {
-        expires: expiresAt,
-        value
+    // Add resources to the cache
+    set(transactionId, resources) {
+      const currentTime = Date.now();
+      const existingResources = cache.get(transactionId) || {
+        utxos: /* @__PURE__ */ new Set(),
+        messages: /* @__PURE__ */ new Set(),
+        timestamp: currentTime
       };
-      return expiresAt;
+      resources.utxos.forEach((utxo) => existingResources.utxos.add(hexlify(utxo)));
+      resources.messages.forEach((message) => existingResources.messages.add(hexlify(message)));
+      cache.set(transactionId, existingResources);
     }
-    getAllData() {
-      return Object.keys(cache).reduce((list, key) => {
-        const data = this.get(key, false);
-        if (data) {
-          list.push(data);
-        }
-        return list;
-      }, []);
+    // Remove resources from the cache for a given transaction ID
+    unset(transactionId) {
+      cache.delete(transactionId);
     }
+    // Get all cached resources and remove expired ones
     getActiveData() {
-      return Object.keys(cache).reduce((list, key) => {
-        const data = this.get(key);
-        if (data) {
-          list.push(data);
+      const allResources = { utxos: [], messages: [] };
+      const currentTime = Date.now();
+      cache.forEach((resource, transactionId) => {
+        if (currentTime - resource.timestamp < this.ttl) {
+          allResources.utxos.push(...resource.utxos);
+          allResources.messages.push(...resource.messages);
+        } else {
+          cache.delete(transactionId);
+        }
+      });
+      return allResources;
+    }
+    // Check if a UTXO ID or message nonce is already cached and not expired
+    isCached(key) {
+      const currentTime = Date.now();
+      for (const [transactionId, resourceData] of cache.entries()) {
+        if (currentTime - resourceData.timestamp > this.ttl) {
+          cache.delete(transactionId);
+        } else if (resourceData.utxos.has(key) || resourceData.messages.has(key)) {
+          return true;
         }
-        return list;
-      }, []);
+      }
+      return false;
     }
-    del(value) {
-      const key = hexlify(value);
-      delete cache[key];
+    clear() {
+      cache.clear();
     }
   };
 
@@ -37953,7 +38398,18 @@ ${MessageFragmentDoc}`;
     "TooManyReceipts",
     "BalanceOverflow",
     "InvalidBlockHeight",
-    "TooManySlots"
+    "TooManySlots",
+    "ExpectedNestedCaller",
+    "MemoryGrowthOverlap",
+    "UninitalizedMemoryAccess",
+    "OverridingConsensusParameters",
+    "UnknownStateTransactionBytecodeRoot",
+    "OverridingStateTransactionBytecode",
+    "BytecodeAlreadyUploaded",
+    "ThePartIsNotSequentiallyConnected",
+    "BlobIdAlreadyUploaded",
+    "BlobNotFound",
+    "GasCostNotDefined"
   ];
   var PANIC_DOC_URL = "https://docs.rs/fuel-asm/latest/fuel_asm/enum.PanicReason.html";
 
@@ -38306,6 +38762,15 @@ ${MessageFragmentDoc}`;
   }) {
     return resolveGasDependentCosts(txBytesSize, gasCosts.s256);
   }
+  function calculateMetadataGasForTxBlob({
+    gasCosts,
+    txBytesSize,
+    witnessBytesSize
+  }) {
+    const txId = resolveGasDependentCosts(txBytesSize, gasCosts.s256);
+    const blobLen = resolveGasDependentCosts(witnessBytesSize, gasCosts.s256);
+    return txId.add(blobLen);
+  }
   var calculateGasFee = (params) => {
     const { gas, gasPrice, priceFactor, tip } = params;
     return gas.mul(gasPrice).div(priceFactor).add(bn(tip));
@@ -38865,7 +39330,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @hidden
      */
     metadataGas(_gasCosts) {
-      throw new Error("Not implemented");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Not implemented");
     }
     /**
      * @hidden
@@ -38940,6 +39405,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       };
       updateAssetInput(baseAssetId, bn(1e11));
       quantities.forEach((q) => updateAssetInput(q.assetId, q.amount));
+      return this;
     }
     /**
      * Retrieves an array of CoinQuantity for each coin output present in the transaction.
@@ -38986,6 +39452,9 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         }
       });
     }
+    byteLength() {
+      return this.toTransactionBytes().byteLength;
+    }
   };
 
   // src/providers/transaction-request/hash-transaction.ts
@@ -39053,6 +39522,70 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     return sha2562(concatenatedData);
   }
 
+  // src/providers/transaction-request/blob-transaction-request.ts
+  var BlobTransactionRequest = class extends BaseTransactionRequest {
+    static from(obj) {
+      if (obj instanceof this) {
+        return obj;
+      }
+      return new this(obj);
+    }
+    /** Type of the transaction */
+    type = TransactionType.Blob;
+    /** Blob ID */
+    blobId;
+    /** Witness index of contract bytecode to create */
+    witnessIndex;
+    /**
+     * Creates an instance `BlobTransactionRequest`.
+     *
+     * @param blobTransactionRequestLike - The initial values for the instance
+     */
+    constructor({ witnessIndex, blobId, ...rest }) {
+      super(rest);
+      this.blobId = blobId;
+      this.witnessIndex = witnessIndex ?? 0;
+    }
+    /**
+     * Converts the transaction request to a `TransactionBlob`.
+     *
+     * @returns The transaction create object.
+     */
+    toTransaction() {
+      const baseTransaction = this.getBaseTransaction();
+      const { witnessIndex, blobId } = this;
+      return {
+        type: TransactionType.Blob,
+        ...baseTransaction,
+        blobId,
+        witnessIndex
+      };
+    }
+    /**
+     * Gets the Transaction Request by hashing the transaction.
+     *
+     * @param chainId - The chain ID.
+     *
+     * @returns - A hash of the transaction, which is the transaction ID.
+     */
+    getTransactionId(chainId) {
+      return hashTransaction(this, chainId);
+    }
+    /**
+     * Calculates the metadata gas cost for a blob transaction.
+     *
+     * @param gasCosts - gas costs passed from the chain.
+     * @returns metadata gas cost for the blob transaction.
+     */
+    metadataGas(gasCosts) {
+      return calculateMetadataGasForTxBlob({
+        gasCosts,
+        txBytesSize: this.byteSize(),
+        witnessBytesSize: this.witnesses[this.witnessIndex].length
+      });
+    }
+  };
+
   // src/providers/transaction-request/storage-slot.ts
   var getStorageValue = (value) => {
     const v = new Uint8Array(32);
@@ -39372,7 +39905,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
 
   // src/providers/transaction-request/utils.ts
   var transactionRequestify = (obj) => {
-    if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest) {
+    if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest || obj instanceof BlobTransactionRequest) {
       return obj;
     }
     const { type: type3 } = obj;
@@ -39383,6 +39916,9 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       case TransactionType.Create: {
         return CreateTransactionRequest.from(obj);
       }
+      case TransactionType.Blob: {
+        return BlobTransactionRequest.from(obj);
+      }
       default: {
         throw new FuelError(
           ErrorCode.UNSUPPORTED_TRANSACTION_TYPE,
@@ -39391,6 +39927,9 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       }
     }
   };
+  var isTransactionTypeScript = (request) => request.type === TransactionType.Script;
+  var isTransactionTypeCreate = (request) => request.type === TransactionType.Create;
+  var isTransactionTypeBlob = (request) => request.type === TransactionType.Blob;
 
   // src/providers/transaction-summary/calculate-tx-fee-for-summary.ts
   var calculateTXFeeForSummary = (params) => {
@@ -39507,17 +40046,47 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   function getInputsCoinAndMessage(inputs) {
     return getInputsByTypes(inputs, [InputType.Coin, InputType.Message]);
   }
+  function isInputCoin(input) {
+    return input.type === InputType.Coin;
+  }
   function getInputsContract(inputs) {
     return getInputsByType(inputs, InputType.Contract);
   }
-  function getInputFromAssetId(inputs, assetId) {
+  function findCoinInput(inputs, assetId) {
     const coinInputs = getInputsCoin(inputs);
-    const messageInputs = getInputsMessage(inputs);
-    const coinInput = coinInputs.find((i) => i.assetId === assetId);
-    const messageInput = messageInputs.find(
-      (_) => assetId === "0x0000000000000000000000000000000000000000000000000000000000000000"
-    );
-    return coinInput || messageInput;
+    return coinInputs.find((i) => i.assetId === assetId);
+  }
+  function aggregateInputsAmountsByAssetAndOwner(inputs, baseAssetID) {
+    const aggregated = /* @__PURE__ */ new Map();
+    getInputsCoinAndMessage(inputs).forEach((input) => {
+      const assetId = isInputCoin(input) ? input.assetId : baseAssetID;
+      const owner = isInputCoin(input) ? input.owner : input.recipient;
+      let ownersMap = aggregated.get(assetId);
+      if (!ownersMap) {
+        ownersMap = /* @__PURE__ */ new Map();
+        aggregated.set(assetId, ownersMap);
+      }
+      let ownerBalance = ownersMap.get(owner);
+      if (!ownerBalance) {
+        ownerBalance = new BN(0);
+        ownersMap.set(owner, ownerBalance);
+      }
+      ownersMap.set(owner, ownerBalance.add(input.amount));
+    });
+    return aggregated;
+  }
+  function findMessageInput(inputs) {
+    return getInputsMessage(inputs)?.[0];
+  }
+  function getInputFromAssetId(inputs, assetId, isBaseAsset = false) {
+    const coinInput = findCoinInput(inputs, assetId);
+    if (coinInput) {
+      return coinInput;
+    }
+    if (isBaseAsset) {
+      return findMessageInput(inputs);
+    }
+    return void 0;
   }
   function getInputContractFromIndex(inputs, inputIndex) {
     if (inputIndex == null) {
@@ -39572,6 +40141,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     TransactionTypeName2["Script"] = "Script";
     TransactionTypeName2["Upgrade"] = "Upgrade";
     TransactionTypeName2["Upload"] = "Upload";
+    TransactionTypeName2["Blob"] = "Blob";
     return TransactionTypeName2;
   })(TransactionTypeName || {});
   var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
@@ -39617,6 +40187,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         return "Create" /* Create */;
       case TransactionType.Script:
         return "Script" /* Script */;
+      case TransactionType.Blob:
+        return "Blob" /* Blob */;
       default:
         throw new FuelError(
           ErrorCode.UNSUPPORTED_TRANSACTION_TYPE,
@@ -39643,6 +40215,9 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   function isTypeUpload(transactionType) {
     return isType(transactionType, "Upload" /* Upload */);
   }
+  function isTypeBlob(transactionType) {
+    return isType(transactionType, "Blob" /* Blob */);
+  }
   function hasSameAssetId(a) {
     return (b) => a.assetId === b.assetId;
   }
@@ -39652,41 +40227,51 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   function getReceiptsMessageOut(receipts) {
     return getReceiptsByType(receipts, ReceiptType.MessageOut);
   }
-  var mergeAssets = (op1, op2) => {
+  function mergeAssets(op1, op2) {
     const assets1 = op1.assetsSent || [];
     const assets2 = op2.assetsSent || [];
-    const filteredAssets = assets2.filter(
-      (asset2) => !assets1.some((asset1) => asset1.assetId === asset2.assetId)
-    );
-    const mergedAssets = assets1.map((asset1) => {
-      const matchingAsset = assets2.find((asset2) => asset2.assetId === asset1.assetId);
-      if (!matchingAsset) {
-        return asset1;
+    const assetMap = /* @__PURE__ */ new Map();
+    assets1.forEach((asset) => {
+      assetMap.set(asset.assetId, { ...asset });
+    });
+    assets2.forEach((asset) => {
+      const existingAsset = assetMap.get(asset.assetId);
+      if (existingAsset) {
+        existingAsset.amount = bn(existingAsset.amount).add(asset.amount);
+      } else {
+        assetMap.set(asset.assetId, { ...asset });
       }
-      const mergedAmount = bn(asset1.amount).add(matchingAsset.amount);
-      return { ...asset1, amount: mergedAmount };
     });
-    return mergedAssets.concat(filteredAssets);
-  };
+    return Array.from(assetMap.values());
+  }
   function isSameOperation(a, b) {
     return a.name === b.name && a.from?.address === b.from?.address && a.to?.address === b.to?.address && a.from?.type === b.from?.type && a.to?.type === b.to?.type;
   }
+  function mergeAssetsSent(existing, toAdd) {
+    if (!toAdd.assetsSent?.length) {
+      return existing.assetsSent;
+    }
+    return existing.assetsSent?.length ? mergeAssets(existing, toAdd) : toAdd.assetsSent;
+  }
+  function mergeCalls(existing, toAdd) {
+    if (!toAdd.calls?.length) {
+      return existing.calls;
+    }
+    return [...existing.calls || [], ...toAdd.calls];
+  }
+  function mergeOperations(existing, toAdd) {
+    return {
+      ...existing,
+      assetsSent: mergeAssetsSent(existing, toAdd),
+      calls: mergeCalls(existing, toAdd)
+    };
+  }
   function addOperation(operations, toAdd) {
-    const allOperations = [...operations];
-    const index = allOperations.findIndex((op) => isSameOperation(op, toAdd));
-    if (allOperations[index]) {
-      const existentOperation = { ...allOperations[index] };
-      if (toAdd.assetsSent?.length) {
-        existentOperation.assetsSent = existentOperation.assetsSent?.length ? mergeAssets(existentOperation, toAdd) : toAdd.assetsSent;
-      }
-      if (toAdd.calls?.length) {
-        existentOperation.calls = [...existentOperation.calls || [], ...toAdd.calls];
-      }
-      allOperations[index] = existentOperation;
-    } else {
-      allOperations.push(toAdd);
+    const existingIndex = operations.findIndex((op) => isSameOperation(op, toAdd));
+    if (existingIndex === -1) {
+      return [...operations, toAdd];
     }
-    return allOperations;
+    return operations.map((op, index) => index === existingIndex ? mergeOperations(op, toAdd) : op);
   }
   function getReceiptsTransferOut(receipts) {
     return getReceiptsByType(receipts, ReceiptType.TransferOut);
@@ -39699,7 +40284,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     const messageOutReceipts = getReceiptsMessageOut(receipts);
     const withdrawFromFuelOperations = messageOutReceipts.reduce(
       (prevWithdrawFromFuelOps, receipt) => {
-        const input = getInputFromAssetId(inputs, baseAssetId);
+        const input = getInputFromAssetId(inputs, baseAssetId, true);
         if (input) {
           const inputAddress = getInputAccountAddress(input);
           const newWithdrawFromFuelOps = addOperation(prevWithdrawFromFuelOps, {
@@ -39728,65 +40313,80 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     );
     return withdrawFromFuelOperations;
   }
+  function getContractCalls(contractInput, abiMap, receipt, rawPayload, maxInputs) {
+    const abi = abiMap?.[contractInput.contractID];
+    if (!abi) {
+      return [];
+    }
+    return [
+      getFunctionCall({
+        abi,
+        receipt,
+        rawPayload,
+        maxInputs
+      })
+    ];
+  }
+  function getAssetsSent(receipt) {
+    return receipt.amount?.isZero() ? void 0 : [
+      {
+        amount: receipt.amount,
+        assetId: receipt.assetId
+      }
+    ];
+  }
+  function processCallReceipt(receipt, contractInput, inputs, abiMap, rawPayload, maxInputs, baseAssetId) {
+    const assetId = receipt.assetId === ZeroBytes32 ? baseAssetId : receipt.assetId;
+    const input = getInputFromAssetId(inputs, assetId, assetId === baseAssetId);
+    if (!input) {
+      return [];
+    }
+    const inputAddress = getInputAccountAddress(input);
+    const calls = getContractCalls(contractInput, abiMap, receipt, rawPayload, maxInputs);
+    return [
+      {
+        name: "Contract call" /* contractCall */,
+        from: {
+          type: 1 /* account */,
+          address: inputAddress
+        },
+        to: {
+          type: 0 /* contract */,
+          address: receipt.to
+        },
+        assetsSent: getAssetsSent(receipt),
+        calls
+      }
+    ];
+  }
   function getContractCallOperations({
     inputs,
     outputs,
     receipts,
     abiMap,
     rawPayload,
-    maxInputs
+    maxInputs,
+    baseAssetId
   }) {
     const contractCallReceipts = getReceiptsCall(receipts);
     const contractOutputs = getOutputsContract(outputs);
-    const contractCallOperations = contractOutputs.reduce((prevOutputCallOps, output3) => {
+    return contractOutputs.flatMap((output3) => {
       const contractInput = getInputContractFromIndex(inputs, output3.inputIndex);
-      if (contractInput) {
-        const newCallOps = contractCallReceipts.reduce((prevContractCallOps, receipt) => {
-          if (receipt.to === contractInput.contractID) {
-            const input = getInputFromAssetId(inputs, receipt.assetId);
-            if (input) {
-              const inputAddress = getInputAccountAddress(input);
-              const calls = [];
-              const abi = abiMap?.[contractInput.contractID];
-              if (abi) {
-                calls.push(
-                  getFunctionCall({
-                    abi,
-                    receipt,
-                    rawPayload,
-                    maxInputs
-                  })
-                );
-              }
-              const newContractCallOps = addOperation(prevContractCallOps, {
-                name: "Contract call" /* contractCall */,
-                from: {
-                  type: 1 /* account */,
-                  address: inputAddress
-                },
-                to: {
-                  type: 0 /* contract */,
-                  address: receipt.to
-                },
-                // if no amount is forwarded to the contract, skip showing assetsSent
-                assetsSent: receipt.amount?.isZero() ? void 0 : [
-                  {
-                    amount: receipt.amount,
-                    assetId: receipt.assetId
-                  }
-                ],
-                calls
-              });
-              return newContractCallOps;
-            }
-          }
-          return prevContractCallOps;
-        }, prevOutputCallOps);
-        return newCallOps;
+      if (!contractInput) {
+        return [];
       }
-      return prevOutputCallOps;
-    }, []);
-    return contractCallOperations;
+      return contractCallReceipts.filter((receipt) => receipt.to === contractInput.contractID).flatMap(
+        (receipt) => processCallReceipt(
+          receipt,
+          contractInput,
+          inputs,
+          abiMap,
+          rawPayload,
+          maxInputs,
+          baseAssetId
+        )
+      );
+    });
   }
   function extractTransferOperationFromReceipt(receipt, contractInputs, changeOutputs) {
     const { to: toAddress, assetId, amount } = receipt;
@@ -39818,32 +40418,40 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   function getTransferOperations({
     inputs,
     outputs,
-    receipts
+    receipts,
+    baseAssetId
   }) {
     let operations = [];
     const coinOutputs = getOutputsCoin(outputs);
     const contractInputs = getInputsContract(inputs);
     const changeOutputs = getOutputsChange(outputs);
-    coinOutputs.forEach((output3) => {
-      const { amount, assetId, to } = output3;
-      const changeOutput = changeOutputs.find((change) => change.assetId === assetId);
-      if (changeOutput) {
+    const aggregated = aggregateInputsAmountsByAssetAndOwner(inputs, baseAssetId);
+    coinOutputs.forEach(({ amount, assetId, to }) => {
+      const txPayers = aggregated.get(assetId) || /* @__PURE__ */ new Map();
+      let selectedPayer;
+      let fallbackPayer;
+      for (const [address, payedAmount] of txPayers) {
+        if (!fallbackPayer) {
+          fallbackPayer = address;
+        }
+        if (payedAmount.gte(amount)) {
+          selectedPayer = address;
+          break;
+        }
+      }
+      selectedPayer = selectedPayer || fallbackPayer;
+      if (selectedPayer) {
         operations = addOperation(operations, {
           name: "Transfer asset" /* transfer */,
           from: {
             type: 1 /* account */,
-            address: changeOutput.to
+            address: selectedPayer
           },
           to: {
             type: 1 /* account */,
             address: to
           },
-          assetsSent: [
-            {
-              assetId,
-              amount
-            }
-          ]
+          assetsSent: [{ assetId, amount }]
         });
       }
     });
@@ -39916,21 +40524,19 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     baseAssetId
   }) {
     if (isTypeCreate(transactionType)) {
-      return [
-        ...getContractCreatedOperations({ inputs, outputs }),
-        ...getTransferOperations({ inputs, outputs, receipts })
-      ];
+      return [...getContractCreatedOperations({ inputs, outputs })];
     }
     if (isTypeScript(transactionType)) {
       return [
-        ...getTransferOperations({ inputs, outputs, receipts }),
+        ...getTransferOperations({ inputs, outputs, receipts, baseAssetId }),
         ...getContractCallOperations({
           inputs,
           outputs,
           receipts,
           abiMap,
           rawPayload,
-          maxInputs
+          maxInputs,
+          baseAssetId
         }),
         ...getWithdrawFromFuelOperations({ inputs, receipts, baseAssetId })
       ];
@@ -40121,6 +40727,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       isTypeScript: isTypeScript(transaction.type),
       isTypeUpgrade: isTypeUpgrade(transaction.type),
       isTypeUpload: isTypeUpload(transaction.type),
+      isTypeBlob: isTypeBlob(transaction.type),
       isStatusFailure,
       isStatusSuccess,
       isStatusPending,
@@ -40144,6 +40751,36 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   }
 
   // src/providers/transaction-response/transaction-response.ts
+  function mapGqlOutputsToTxOutputs(outputs) {
+    return outputs.map((o) => {
+      const obj = "amount" in o ? { ...o, amount: bn(o.amount) } : o;
+      switch (obj.type) {
+        case "CoinOutput":
+          return { ...obj, type: OutputType.Coin };
+        case "ContractOutput":
+          return {
+            ...obj,
+            type: OutputType.Contract,
+            inputIndex: parseInt(obj.inputIndex, 10)
+          };
+        case "ChangeOutput":
+          return {
+            ...obj,
+            type: OutputType.Change
+          };
+        case "VariableOutput":
+          return { ...obj, type: OutputType.Variable };
+        case "ContractCreated":
+          return {
+            ...obj,
+            type: OutputType.ContractCreated,
+            contractId: obj.contract
+          };
+        default:
+          return assertUnreachable(obj);
+      }
+    });
+  }
   var TransactionResponse = class {
     /** Transaction ID */
     id;
@@ -40153,17 +40790,20 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     gasUsed = bn(0);
     /** The graphql Transaction with receipts object. */
     gqlTransaction;
+    request;
+    status;
     abis;
     /**
      * Constructor for `TransactionResponse`.
      *
-     * @param id - The transaction ID.
+     * @param tx - The transaction ID or TransactionRequest.
      * @param provider - The provider.
      */
-    constructor(id, provider, abis) {
-      this.id = id;
+    constructor(tx, provider, abis) {
+      this.id = typeof tx === "string" ? tx : tx.getTransactionId(provider.getChainId());
       this.provider = provider;
       this.abis = abis;
+      this.request = typeof tx === "string" ? void 0 : tx;
     }
     /**
      * Async constructor for `TransactionResponse`. This method can be used to create
@@ -40178,6 +40818,54 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       await response.fetch();
       return response;
     }
+    applyMalleableSubscriptionFields(transaction) {
+      const status = this.status;
+      if (!status) {
+        return;
+      }
+      const tx = transaction;
+      if (status.type === "SuccessStatus" || status.type === "FailureStatus") {
+        tx.inputs = tx.inputs.map((input, idx) => {
+          if ("txPointer" in input) {
+            const correspondingInput = status.transaction.inputs?.[idx];
+            return {
+              ...input,
+              txPointer: TxPointerCoder.decodeFromGqlScalar(correspondingInput.txPointer)
+            };
+          }
+          return input;
+        });
+        tx.outputs = mapGqlOutputsToTxOutputs(status.transaction.outputs);
+        if ("receiptsRoot" in status.transaction) {
+          tx.receiptsRoot = status.transaction.receiptsRoot;
+        }
+      }
+    }
+    async getTransaction() {
+      if (this.request) {
+        const tx = this.request.toTransaction();
+        this.applyMalleableSubscriptionFields(tx);
+        return {
+          tx,
+          bytes: this.request.toTransactionBytes()
+        };
+      }
+      const gqlTransaction = this.gqlTransaction ?? await this.fetch();
+      return {
+        tx: this.decodeTransaction(gqlTransaction),
+        bytes: arrayify(gqlTransaction.rawPayload)
+      };
+    }
+    getReceipts() {
+      const status = this.status ?? this.gqlTransaction?.status;
+      switch (status?.type) {
+        case "SuccessStatus":
+        case "FailureStatus":
+          return status.receipts.map(processGqlReceipt);
+        default:
+          return [];
+      }
+    }
     /**
      * Fetch the transaction with receipts from the provider.
      *
@@ -40188,11 +40876,12 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         transactionId: this.id
       });
       if (!response.transaction) {
-        const subscription = this.provider.operations.statusChange({
+        const subscription = await this.provider.operations.statusChange({
           transactionId: this.id
         });
         for await (const { statusChange } of subscription) {
           if (statusChange) {
+            this.status = statusChange;
             break;
           }
         }
@@ -40221,28 +40910,17 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @returns
      */
     async getTransactionSummary(contractsAbiMap) {
-      let transaction = this.gqlTransaction;
-      if (!transaction) {
-        transaction = await this.fetch();
-      }
-      const decodedTransaction = this.decodeTransaction(
-        transaction
-      );
-      let txReceipts = [];
-      if (transaction?.status && "receipts" in transaction.status) {
-        txReceipts = transaction.status.receipts;
-      }
-      const receipts = txReceipts.map(processGqlReceipt) || [];
+      const { tx: transaction, bytes: transactionBytes } = await this.getTransaction();
       const { gasPerByte, gasPriceFactor, gasCosts, maxGasPerTx } = this.provider.getGasConfig();
       const gasPrice = await this.provider.getLatestGasPrice();
       const maxInputs = this.provider.getChain().consensusParameters.txParameters.maxInputs;
       const baseAssetId = this.provider.getBaseAssetId();
       const transactionSummary = assembleTransactionSummary({
         id: this.id,
-        receipts,
-        transaction: decodedTransaction,
-        transactionBytes: arrayify(transaction.rawPayload),
-        gqlTransactionStatus: transaction.status,
+        receipts: this.getReceipts(),
+        transaction,
+        transactionBytes,
+        gqlTransactionStatus: this.status ?? this.gqlTransaction?.status,
         gasPerByte,
         gasPriceFactor,
         abiMap: contractsAbiMap,
@@ -40259,11 +40937,13 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       if (status && status !== "SubmittedStatus") {
         return;
       }
-      const subscription = this.provider.operations.statusChange({
+      const subscription = await this.provider.operations.statusChange({
         transactionId: this.id
       });
       for await (const { statusChange } of subscription) {
+        this.status = statusChange;
         if (statusChange.type === "SqueezedOutStatus") {
+          this.unsetResourceCache();
           throw new FuelError(
             ErrorCode.TRANSACTION_SQUEEZED_OUT,
             `Transaction Squeezed Out with reason: ${statusChange.reason}`
@@ -40273,7 +40953,6 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
           break;
         }
       }
-      await this.fetch();
     }
     /**
      * Assembles the result of a transaction by retrieving the transaction summary,
@@ -40290,7 +40969,6 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     async assembleResult(contractsAbiMap) {
       const transactionSummary = await this.getTransactionSummary(contractsAbiMap);
       const transactionResult = {
-        gqlTransaction: this.gqlTransaction,
         ...transactionSummary
       };
       let logs = [];
@@ -40302,9 +40980,11 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         );
         transactionResult.logs = logs;
       }
-      const { gqlTransaction, receipts } = transactionResult;
-      if (gqlTransaction.status?.type === "FailureStatus") {
-        const { reason } = gqlTransaction.status;
+      const { receipts } = transactionResult;
+      const status = this.status ?? this.gqlTransaction?.status;
+      if (status?.type === "FailureStatus") {
+        this.unsetResourceCache();
+        const { reason } = status;
         throw extractTxError({
           receipts,
           statusReason: reason,
@@ -40330,6 +41010,9 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     async wait(contractsAbiMap) {
       return this.waitForResult(contractsAbiMap);
     }
+    unsetResourceCache() {
+      this.provider.cache?.unset(this.id);
+    }
   };
 
   // src/providers/utils/auto-retry-fetch.ts
@@ -40372,7 +41055,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   var MAX_RETRIES = 10;
   var RESOURCES_PAGE_SIZE_LIMIT = 512;
   var BLOCKS_PAGE_SIZE_LIMIT = 5;
-  var DEFAULT_UTXOS_CACHE_TTL = 2e4;
+  var DEFAULT_RESOURCE_CACHE_TTL = 2e4;
   var processGqlChain = (chain) => {
     const { name, daHeight, consensusParameters, latestBlock } = chain;
     const {
@@ -40455,22 +41138,22 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       __publicField(this, "cache");
       __publicField(this, "options", {
         timeout: void 0,
-        cacheUtxo: void 0,
+        resourceCacheTTL: void 0,
         fetch: void 0,
         retryOptions: void 0
       });
       this.options = { ...this.options, ...options };
       this.url = url;
       this.operations = this.createOperations();
-      const { cacheUtxo } = this.options;
-      if (isDefined(cacheUtxo)) {
-        if (cacheUtxo !== -1) {
-          this.cache = new MemoryCache(cacheUtxo);
+      const { resourceCacheTTL } = this.options;
+      if (isDefined(resourceCacheTTL)) {
+        if (resourceCacheTTL !== -1) {
+          this.cache = new ResourceCache(resourceCacheTTL);
         } else {
           this.cache = void 0;
         }
       } else {
-        this.cache = new MemoryCache(DEFAULT_UTXOS_CACHE_TTL);
+        this.cache = new ResourceCache(DEFAULT_RESOURCE_CACHE_TTL);
       }
     }
     /** @hidden */
@@ -40573,9 +41256,9 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @returns A promise that resolves to the Chain and NodeInfo.
      */
     async fetchChainAndNodeInfo() {
-      const chain = await this.fetchChain();
       const nodeInfo = await this.fetchNode();
       _Provider.ensureClientVersionIsSupported(nodeInfo);
+      const chain = await this.fetchChain();
       return {
         chain,
         nodeInfo
@@ -40621,7 +41304,7 @@ Supported fuel-core version: ${supportedVersion}.`
         const opDefinition = query.definitions.find((x) => x.kind === "OperationDefinition");
         const isSubscription = opDefinition?.operation === "subscription";
         if (isSubscription) {
-          return new FuelGraphqlSubscriber({
+          return FuelGraphqlSubscriber.create({
             url: this.url,
             query,
             fetchFn: (url, requestInit) => fetchFn(url, requestInit, this.options),
@@ -40702,6 +41385,21 @@ Supported fuel-core version: ${supportedVersion}.`
       } = this.getChain();
       return baseAssetId;
     }
+    validateTransaction(tx, consensusParameters) {
+      const { maxOutputs, maxInputs } = consensusParameters.txParameters;
+      if (bn(tx.inputs.length).gt(maxInputs)) {
+        throw new FuelError(
+          ErrorCode.MAX_INPUTS_EXCEEDED,
+          "The transaction exceeds the maximum allowed number of inputs."
+        );
+      }
+      if (bn(tx.outputs.length).gt(maxOutputs)) {
+        throw new FuelError(
+          ErrorCode.MAX_OUTPUTS_EXCEEDED,
+          "The transaction exceeds the maximum allowed number of outputs."
+        );
+      }
+    }
     /**
      * Submits a transaction to the chain to be executed.
      *
@@ -40718,16 +41416,18 @@ Supported fuel-core version: ${supportedVersion}.`
       if (estimateTxDependencies) {
         await this.estimateTxDependencies(transactionRequest);
       }
+      const { consensusParameters } = this.getChain();
+      this.validateTransaction(transactionRequest, consensusParameters);
       const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
       let abis;
-      if (transactionRequest.type === TransactionType.Script) {
+      if (isTransactionTypeScript(transactionRequest)) {
         abis = transactionRequest.abis;
       }
       const {
         submit: { id: transactionId }
       } = await this.operations.submit({ encodedTransaction });
-      __privateMethod(this, _cacheInputs, cacheInputs_fn).call(this, transactionRequest.inputs);
-      return new TransactionResponse(transactionId, this, abis);
+      __privateMethod(this, _cacheInputs, cacheInputs_fn).call(this, transactionRequest.inputs, transactionId);
+      return new TransactionResponse(transactionRequest, this, abis);
     }
     /**
      * Executes a transaction without actually submitting it to the chain.
@@ -40796,7 +41496,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns A promise that resolves to the estimate transaction dependencies.
      */
     async estimateTxDependencies(transactionRequest) {
-      if (transactionRequest.type === TransactionType.Create) {
+      if (isTransactionTypeCreate(transactionRequest)) {
         return {
           receipts: [],
           outputVariables: 0,
@@ -40818,7 +41518,7 @@ Supported fuel-core version: ${supportedVersion}.`
         dryRunStatus = status;
         const { missingOutputVariables, missingOutputContractIds } = getReceiptsWithMissingData(receipts);
         const hasMissingOutputs = missingOutputVariables.length !== 0 || missingOutputContractIds.length !== 0;
-        if (hasMissingOutputs) {
+        if (hasMissingOutputs && isTransactionTypeScript(transactionRequest)) {
           outputVariables += missingOutputVariables.length;
           transactionRequest.addVariableOutputs(missingOutputVariables.length);
           missingOutputContractIds.forEach(({ contractId }) => {
@@ -40860,7 +41560,7 @@ Supported fuel-core version: ${supportedVersion}.`
       const allRequests = clone_default(transactionRequests);
       const serializedTransactionsMap = /* @__PURE__ */ new Map();
       allRequests.forEach((req, index) => {
-        if (req.type === TransactionType.Script) {
+        if (isTransactionTypeScript(req)) {
           serializedTransactionsMap.set(index, hexlify(req.toTransactionBytes()));
         }
       });
@@ -40886,7 +41586,7 @@ Supported fuel-core version: ${supportedVersion}.`
           );
           const hasMissingOutputs = missingOutputVariables.length > 0 || missingOutputContractIds.length > 0;
           const request = allRequests[requestIdx];
-          if (hasMissingOutputs && request?.type === TransactionType.Script) {
+          if (hasMissingOutputs && isTransactionTypeScript(request)) {
             result.outputVariables += missingOutputVariables.length;
             request.addVariableOutputs(missingOutputVariables.length);
             missingOutputContractIds.forEach(({ contractId }) => {
@@ -40950,7 +41650,7 @@ Supported fuel-core version: ${supportedVersion}.`
         tip: transactionRequest.tip
       }).add(1);
       let gasLimit = bn(0);
-      if (transactionRequest.type === TransactionType.Script) {
+      if (isTransactionTypeScript(transactionRequest)) {
         gasLimit = transactionRequest.gasLimit;
         if (transactionRequest.gasLimit.eq(0)) {
           transactionRequest.gasLimit = minGas;
@@ -41018,14 +41718,14 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     async getTransactionCost(transactionRequestLike, { signatureCallback } = {}) {
       const txRequestClone = clone_default(transactionRequestify(transactionRequestLike));
-      const isScriptTransaction = txRequestClone.type === TransactionType.Script;
       const updateMaxFee = txRequestClone.maxFee.eq(0);
+      const isScriptTransaction = isTransactionTypeScript(txRequestClone);
       if (isScriptTransaction) {
         txRequestClone.gasLimit = bn(0);
       }
       const signedRequest = clone_default(txRequestClone);
       let addedSignatures = 0;
-      if (signatureCallback && isScriptTransaction) {
+      if (signatureCallback && isTransactionTypeScript(signedRequest)) {
         const lengthBefore = signedRequest.witnesses.length;
         await signatureCallback(signedRequest);
         addedSignatures = signedRequest.witnesses.length - lengthBefore;
@@ -41121,10 +41821,9 @@ Supported fuel-core version: ${supportedVersion}.`
         utxos: excludedIds?.utxos?.map((id) => hexlify(id)) || []
       };
       if (this.cache) {
-        const uniqueUtxos = new Set(
-          excludeInput.utxos.concat(this.cache?.getActiveData().map((id) => hexlify(id)))
-        );
-        excludeInput.utxos = Array.from(uniqueUtxos);
+        const cached = this.cache.getActiveData();
+        excludeInput.messages.push(...cached.messages);
+        excludeInput.utxos.push(...cached.utxos);
       }
       const coinsQuery = {
         owner: ownerAddress.toB256(),
@@ -41609,15 +42308,22 @@ Supported fuel-core version: ${supportedVersion}.`
   };
   var Provider = _Provider;
   _cacheInputs = new WeakSet();
-  cacheInputs_fn = function(inputs) {
+  cacheInputs_fn = function(inputs, transactionId) {
     if (!this.cache) {
       return;
     }
-    inputs.forEach((input) => {
-      if (input.type === InputType.Coin) {
-        this.cache?.set(input.id);
-      }
-    });
+    const inputsToCache = inputs.reduce(
+      (acc, input) => {
+        if (input.type === InputType.Coin) {
+          acc.utxos.push(input.id);
+        } else if (input.type === InputType.Message) {
+          acc.messages.push(input.nonce);
+        }
+        return acc;
+      },
+      { utxos: [], messages: [] }
+    );
+    this.cache.set(transactionId, inputsToCache);
   };
   /** @hidden */
   __publicField(Provider, "chainInfoCache", {});
@@ -41670,7 +42376,6 @@ Supported fuel-core version: ${supportedVersion}.`
       baseAssetId
     });
     return {
-      gqlTransaction,
       ...transactionInfo
     };
   }
@@ -41684,6 +42389,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const gasPrice = await provider.getLatestGasPrice();
     const baseAssetId = provider.getBaseAssetId();
     const transactionSummary = assembleTransactionSummary({
+      id: transactionRequest.getTransactionId(provider.getChainId()),
       receipts,
       transaction,
       transactionBytes,
@@ -41736,7 +42442,6 @@ Supported fuel-core version: ${supportedVersion}.`
         baseAssetId
       });
       const output3 = {
-        gqlTransaction,
         ...transactionSummary
       };
       return output3;
@@ -41920,7 +42625,7 @@ Supported fuel-core version: ${supportedVersion}.`
   };
 
   // src/account.ts
-  var MAX_FUNDING_ATTEMPTS = 2;
+  var MAX_FUNDING_ATTEMPTS = 5;
   var Account = class extends AbstractAccount {
     /**
      * The address associated with the account.
@@ -42033,7 +42738,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns A promise that resolves to the funded transaction request.
      */
     async fund(request, params) {
-      const { addedSignatures, estimatedPredicates, requiredQuantities, updateMaxFee } = params;
+      const { addedSignatures, estimatedPredicates, requiredQuantities, updateMaxFee, gasPrice } = params;
       const fee = request.maxFee;
       const baseAssetId = this.provider.getBaseAssetId();
       const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || bn(0);
@@ -42081,10 +42786,12 @@ Supported fuel-core version: ${supportedVersion}.`
           );
         }
         if (!updateMaxFee) {
+          needsToBeFunded = false;
           break;
         }
         const { maxFee: newFee } = await this.provider.estimateTxGasAndFee({
-          transactionRequest: requestToReestimate2
+          transactionRequest: requestToReestimate2,
+          gasPrice
         });
         const totalBaseAssetOnInputs = getAssetAmountInRequestInputs(
           request.inputs,
@@ -42104,6 +42811,12 @@ Supported fuel-core version: ${supportedVersion}.`
         }
         fundingAttempts += 1;
       }
+      if (needsToBeFunded) {
+        throw new FuelError(
+          ErrorCode.NOT_ENOUGH_FUNDS,
+          `The account ${this.address} does not have enough base asset funds to cover the transaction execution.`
+        );
+      }
       request.updatePredicateGasUsed(estimatedPredicates);
       const requestToReestimate = clone_default(request);
       if (addedSignatures) {
@@ -42286,10 +42999,34 @@ Supported fuel-core version: ${supportedVersion}.`
       const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
       const requiredQuantities = mergeQuantities(coinOutputsQuantities, quantities);
       const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: bn("100000000000000000") }];
-      const resources = this.generateFakeResources(
-        mergeQuantities(requiredQuantities, transactionFeeForDryRun)
+      const findAssetInput = (assetId) => txRequestClone.inputs.find((input) => {
+        if ("assetId" in input) {
+          return input.assetId === assetId;
+        }
+        if ("recipient" in input) {
+          return baseAssetId === assetId;
+        }
+        return false;
+      });
+      const updateAssetInput = (assetId, quantity) => {
+        const assetInput = findAssetInput(assetId);
+        const usedQuantity = quantity;
+        if (assetInput && "amount" in assetInput) {
+          assetInput.amount = usedQuantity;
+        } else {
+          txRequestClone.addResources(
+            this.generateFakeResources([
+              {
+                amount: quantity,
+                assetId
+              }
+            ])
+          );
+        }
+      };
+      mergeQuantities(requiredQuantities, transactionFeeForDryRun).forEach(
+        ({ amount, assetId }) => updateAssetInput(assetId, amount)
       );
-      txRequestClone.addResources(resources);
       const txCost = await this.provider.getTransactionCost(txRequestClone, {
         signatureCallback
       });
@@ -44211,53 +44948,6 @@ Supported fuel-core version: ${supportedVersion}.`
     }
   };
 
-  // ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/stringify.js
-  var byteToHex = [];
-  for (let i = 0; i < 256; ++i) {
-    byteToHex.push((i + 256).toString(16).slice(1));
-  }
-  function unsafeStringify(arr, offset = 0) {
-    return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-  }
-
-  // ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/rng.js
-  var import_node_crypto = __toESM(__require("crypto"));
-  var rnds8Pool = new Uint8Array(256);
-  var poolPtr = rnds8Pool.length;
-  function rng() {
-    if (poolPtr > rnds8Pool.length - 16) {
-      import_node_crypto.default.randomFillSync(rnds8Pool);
-      poolPtr = 0;
-    }
-    return rnds8Pool.slice(poolPtr, poolPtr += 16);
-  }
-
-  // ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/native.js
-  var import_node_crypto2 = __toESM(__require("crypto"));
-  var native_default = {
-    randomUUID: import_node_crypto2.default.randomUUID
-  };
-
-  // ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v4.js
-  function v4(options, buf, offset) {
-    if (native_default.randomUUID && !buf && !options) {
-      return native_default.randomUUID();
-    }
-    options = options || {};
-    const rnds = options.random || (options.rng || rng)();
-    rnds[6] = rnds[6] & 15 | 64;
-    rnds[8] = rnds[8] & 63 | 128;
-    if (buf) {
-      offset = offset || 0;
-      for (let i = 0; i < 16; ++i) {
-        buf[offset + i] = rnds[i];
-      }
-      return buf;
-    }
-    return unsafeStringify(rnds);
-  }
-  var v4_default = v4;
-
   // src/wallet/keystore-wallet.ts
   var DEFAULT_KDF_PARAMS_LOG_N = 13;
   var DEFAULT_KDF_PARAMS_R = 8;
@@ -44288,7 +44978,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const macHashUint8Array = keccak2562(data);
     const mac = stringFromBuffer2(macHashUint8Array, "hex");
     const keystore = {
-      id: v4_default(),
+      id: randomUUID2(),
       version: 3,
       address: removeHexPrefix(ownerAddress.toHexString()),
       crypto: {
@@ -47637,14 +48327,14 @@ Supported fuel-core version: ${supportedVersion}.`
      * @param bytecode - The bytecode of the predicate.
      * @param abi - The JSON ABI of the predicate.
      * @param provider - The provider used to interact with the blockchain.
-     * @param inputData - The predicate input data (optional).
+     * @param data - The predicate input data (optional).
      * @param configurableConstants - Optional configurable constants for the predicate.
      */
     constructor({
       bytecode,
       abi,
       provider,
-      inputData,
+      data,
       configurableConstants
     }) {
       const { predicateBytes, predicateInterface } = Predicate.processPredicateData(
@@ -47656,8 +48346,8 @@ Supported fuel-core version: ${supportedVersion}.`
       super(address, provider);
       this.bytes = predicateBytes;
       this.interface = predicateInterface;
-      if (inputData !== void 0 && inputData.length > 0) {
-        this.predicateData = inputData;
+      if (data !== void 0 && data.length > 0) {
+        this.predicateData = data;
       }
     }
     /**
@@ -47784,16 +48474,23 @@ Supported fuel-core version: ${supportedVersion}.`
       const mutatedBytes = bytes3;
       try {
         if (!abiInterface) {
-          throw new Error(
+          throw new FuelError(
+            ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
             "Cannot validate configurable constants because the Predicate was instantiated without a JSON ABI"
           );
         }
         if (Object.keys(abiInterface.configurables).length === 0) {
-          throw new Error("Predicate has no configurable constants to be set");
+          throw new FuelError(
+            ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
+            "Predicate has no configurable constants to be set"
+          );
         }
         Object.entries(configurableConstants).forEach(([key, value]) => {
           if (!abiInterface?.configurables[key]) {
-            throw new Error(`No configurable constant named '${key}' found in the Predicate`);
+            throw new FuelError(
+              ErrorCode.CONFIGURABLE_NOT_FOUND,
+              `No configurable constant named '${key}' found in the Predicate`
+            );
           }
           const { offset } = abiInterface.configurables[key];
           const encoded = abiInterface.encodeConfigurable(key, value);
@@ -47905,7 +48602,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Always true.
      */
     async ping() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return the current version of the connector
@@ -47914,7 +48611,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns boolean - connection status.
      */
     async version() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return true if the connector is connected
@@ -47923,7 +48620,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns The connection status.
      */
     async isConnected() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return all the accounts authorized for the
@@ -47932,7 +48629,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns The accounts addresses strings
      */
     async accounts() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should start the connection process and return
@@ -47944,7 +48641,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns boolean - connection status.
      */
     async connect() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should disconnect the current connection and
@@ -47954,7 +48651,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns The connection status.
      */
     async disconnect() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should start the sign message process and return
@@ -47966,7 +48663,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Message signature
      */
     async signMessage(_address, _message) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should start the sign transaction process and return
@@ -47978,7 +48675,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Transaction signature
      */
     async signTransaction(_address, _transaction) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should start the send transaction process and return
@@ -47994,7 +48691,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns The transaction id
      */
     async sendTransaction(_address, _transaction) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return the current account selected inside the connector, if the account
@@ -48005,7 +48702,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns The current account selected otherwise null.
      */
     async currentAccount() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should add the assets metadata to the connector and return true if the asset
@@ -48019,7 +48716,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns True if the asset was added successfully
      */
     async addAssets(_assets) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should add the asset metadata to the connector and return true if the asset
@@ -48033,7 +48730,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns True if the asset was added successfully
      */
     async addAsset(_asset) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return all the assets added to the connector. If a connection is already established.
@@ -48041,7 +48738,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Array of assets metadata from the connector vinculated to the all accounts from a specific Wallet.
      */
     async assets() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should start the add network process and return true if the network was added successfully.
@@ -48052,7 +48749,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Return true if the network was added successfully
      */
     async addNetwork(_networkUrl) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should start the select network process and return true if the network has change successfully.
@@ -48063,7 +48760,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Return true if the network was added successfully
      */
     async selectNetwork(_network) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return all the networks available from the connector. If the connection is already established.
@@ -48071,7 +48768,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Return all the networks added to the connector.
      */
     async networks() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return the current network selected inside the connector. Even if the connection is not established.
@@ -48079,7 +48776,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Return the current network selected inside the connector.
      */
     async currentNetwork() {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should add the ABI to the connector and return true if the ABI was added successfully.
@@ -48089,7 +48786,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Return true if the ABI was added successfully.
      */
     async addABI(_contractId, _abi) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return the ABI from the connector vinculated to the all accounts from a specific Wallet.
@@ -48098,7 +48795,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns The ABI if it exists, otherwise return null.
      */
     async getABI(_id) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Should return true if the abi exists in the connector vinculated to the all accounts from a specific Wallet.
@@ -48107,7 +48804,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns Returns true if the abi exists or false if not.
      */
     async hasABI(_id) {
-      throw new Error("Method not implemented.");
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
     }
     /**
      * Event listener for the connector.
@@ -48162,7 +48859,7 @@ Supported fuel-core version: ${supportedVersion}.`
   async function withTimeout(promise, timeout = 1050) {
     const timeoutPromise = new Promise((resolve, reject) => {
       setTimeout(() => {
-        reject(new Error("Promise timed out"));
+        reject(new FuelError(FuelError.CODES.TIMEOUT_EXCEEDED, "Promise timed out"));
       }, timeout);
     });
     return Promise.race([timeoutPromise, promise]);
@@ -48249,7 +48946,8 @@ Supported fuel-core version: ${supportedVersion}.`
       const hasConnector = await this.hasConnector();
       await this.pingConnector();
       if (!this._currentConnector || !hasConnector) {
-        throw new Error(
+        throw new FuelError(
+          ErrorCode.MISSING_CONNECTOR,
           `No connector selected for calling ${method}. Use hasConnector before executing other methods.`
         );
       }
@@ -48313,7 +49011,7 @@ Supported fuel-core version: ${supportedVersion}.`
           cacheTime: PING_CACHE_TIME
         })();
       } catch {
-        throw new Error("Current connector is not available.");
+        throw new FuelError(ErrorCode.INVALID_PROVIDER, "Current connector is not available.");
       }
     }
     /**