@chainvue/verus-sdk 0.13.0 → 0.14.0

package/dist/bundle.js

@@ -6562,7 +6562,7 @@ var require_TransferDestination = __commonJS({
     exports2.FLAG_DEST_AUX = new bn_js_1.BN(64, 10);
     exports2.FLAG_DEST_GATEWAY = new bn_js_1.BN(128, 10);
     exports2.FLAG_MASK = exports2.FLAG_DEST_AUX.add(exports2.FLAG_DEST_GATEWAY);
-    var TransferDestination3 = class _TransferDestination {
+    var TransferDestination4 = class _TransferDestination {
       constructor(data) {
         this.type = exports2.DEST_INVALID;
         this.destination_bytes = Buffer.alloc(0);
@@ -6764,7 +6764,7 @@ var require_TransferDestination = __commonJS({
         return retVal;
       }
     };
-    exports2.TransferDestination = TransferDestination3;
+    exports2.TransferDestination = TransferDestination4;
   }
 });
 
@@ -6955,7 +6955,7 @@ var require_CurrencyValueMap = __commonJS({
     var vdxf_1 = require_vdxf();
     var { BufferReader, BufferWriter } = bufferutils_1.default;
     var numberConversion_1 = require_numberConversion();
-    var CurrencyValueMap2 = class _CurrencyValueMap {
+    var CurrencyValueMap3 = class _CurrencyValueMap {
       constructor(data = {}) {
         this.value_map = new Map(data.value_map || []);
         this.multivalue = !!data.multivalue;
@@ -7044,7 +7044,7 @@ var require_CurrencyValueMap = __commonJS({
         return new _CurrencyValueMap({ value_map, multivalue });
       }
     };
-    exports2.CurrencyValueMap = CurrencyValueMap2;
+    exports2.CurrencyValueMap = CurrencyValueMap3;
   }
 });
 
@@ -7056,7 +7056,7 @@ var require_KeyID = __commonJS({
     exports2.KeyID = void 0;
     var vdxf_1 = require_vdxf();
     var Hash160_1 = require_Hash160();
-    var KeyID2 = class _KeyID extends Hash160_1.Hash160SerEnt {
+    var KeyID3 = class _KeyID extends Hash160_1.Hash160SerEnt {
       constructor(hash = Buffer.alloc(0)) {
         super(hash, vdxf_1.R_ADDR_VERSION, false);
       }
@@ -7069,7 +7069,7 @@ var require_KeyID = __commonJS({
         return new _KeyID(Hash160_1.Hash160SerEnt.fromAddress(address2, false).hash);
       }
     };
-    exports2.KeyID = KeyID2;
+    exports2.KeyID = KeyID3;
   }
 });
 
@@ -9592,7 +9592,7 @@ var require_Identity = __commonJS({
     exports2.IDENTITY_MAX_UNLOCK_DELAY = new bn_js_1.BN(60).mul(new bn_js_1.BN(24)).mul(new bn_js_1.BN(22)).mul(new bn_js_1.BN(365));
     exports2.IDENTITY_MAX_NAME_LEN = new bn_js_1.BN(64);
     var { BufferReader, BufferWriter } = bufferutils_1.default;
-    var Identity5 = class _Identity extends Principal_1.Principal {
+    var Identity7 = class _Identity extends Principal_1.Principal {
       constructor(data) {
         super(data);
         if (data === null || data === void 0 ? void 0 : data.version)
@@ -9959,14 +9959,14 @@ var require_Identity = __commonJS({
         return _Identity.internalFromJson(json, _Identity);
       }
     };
-    exports2.Identity = Identity5;
-    Identity5.VERSION_INVALID = new bn_js_1.BN(0);
-    Identity5.VERSION_VERUSID = new bn_js_1.BN(1);
-    Identity5.VERSION_VAULT = new bn_js_1.BN(2);
-    Identity5.VERSION_PBAAS = new bn_js_1.BN(3);
-    Identity5.VERSION_CURRENT = Identity5.VERSION_PBAAS;
-    Identity5.VERSION_FIRSTVALID = new bn_js_1.BN(1);
-    Identity5.VERSION_LASTVALID = new bn_js_1.BN(3);
+    exports2.Identity = Identity7;
+    Identity7.VERSION_INVALID = new bn_js_1.BN(0);
+    Identity7.VERSION_VERUSID = new bn_js_1.BN(1);
+    Identity7.VERSION_VAULT = new bn_js_1.BN(2);
+    Identity7.VERSION_PBAAS = new bn_js_1.BN(3);
+    Identity7.VERSION_CURRENT = Identity7.VERSION_PBAAS;
+    Identity7.VERSION_FIRSTVALID = new bn_js_1.BN(1);
+    Identity7.VERSION_LASTVALID = new bn_js_1.BN(3);
   }
 });
 
@@ -10072,7 +10072,7 @@ var require_ReserveTransfer = __commonJS({
       type: TransferDestination_1.DEST_PKH,
       destination_bytes: (0, address_1.fromBase58Check)("RTqQe58LSj2yr5CrwYFwcsAQ1edQwmrkUU").hash
     });
-    var ReserveTransfer2 = class extends TokenOutput_1.TokenOutput {
+    var ReserveTransfer3 = class extends TokenOutput_1.TokenOutput {
       constructor(data) {
         super(data);
         this.flags = exports2.RESERVE_TRANSFER_INVALID;
@@ -10194,7 +10194,7 @@ var require_ReserveTransfer = __commonJS({
         return reader.offset;
       }
     };
-    exports2.ReserveTransfer = ReserveTransfer2;
+    exports2.ReserveTransfer = ReserveTransfer3;
   }
 });
 
@@ -10594,7 +10594,7 @@ var require_PubKey = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.PubKey = void 0;
     var bufferutils_1 = require_bufferutils();
-    var PubKey = class _PubKey {
+    var PubKey2 = class _PubKey {
       constructor(bytes = Buffer.alloc(0), compressed = true) {
         this.bytes = bytes;
         this.compressed = compressed;
@@ -10616,9 +10616,9 @@ var require_PubKey = __commonJS({
         return writer.buffer;
       }
     };
-    exports2.PubKey = PubKey;
-    PubKey.PUBLIC_KEY_SIZE = 65;
-    PubKey.COMPRESSED_PUBLIC_KEY_SIZE = 33;
+    exports2.PubKey = PubKey2;
+    PubKey2.PUBLIC_KEY_SIZE = 65;
+    PubKey2.COMPRESSED_PUBLIC_KEY_SIZE = 33;
   }
 });
 
@@ -10667,7 +10667,7 @@ var require_TxDestination = __commonJS({
     var PubKey_1 = require_PubKey();
     var UnknownID_1 = require_UnknownID();
     var { BufferReader, BufferWriter } = bufferutils_1.default;
-    var TxDestination2 = class _TxDestination {
+    var TxDestination3 = class _TxDestination {
       constructor(data = new NoDestination_1.NoDestination(), type) {
         this.data = data;
         if (!type) {
@@ -10752,15 +10752,15 @@ var require_TxDestination = __commonJS({
         return Buffer.from(this.toBuffer().subarray(varuint_1.default.encodingLength(this.data.toBuffer().length)));
       }
     };
-    exports2.TxDestination = TxDestination2;
-    TxDestination2.TYPE_INVALID = new bn_js_1.BN(0, 10);
-    TxDestination2.TYPE_PK = new bn_js_1.BN(1, 10);
-    TxDestination2.TYPE_PKH = new bn_js_1.BN(2, 10);
-    TxDestination2.TYPE_SH = new bn_js_1.BN(3, 10);
-    TxDestination2.TYPE_ID = new bn_js_1.BN(4, 10);
-    TxDestination2.TYPE_INDEX = new bn_js_1.BN(5, 10);
-    TxDestination2.TYPE_QUANTUM = new bn_js_1.BN(6, 10);
-    TxDestination2.TYPE_LAST = new bn_js_1.BN(6, 10);
+    exports2.TxDestination = TxDestination3;
+    TxDestination3.TYPE_INVALID = new bn_js_1.BN(0, 10);
+    TxDestination3.TYPE_PK = new bn_js_1.BN(1, 10);
+    TxDestination3.TYPE_PKH = new bn_js_1.BN(2, 10);
+    TxDestination3.TYPE_SH = new bn_js_1.BN(3, 10);
+    TxDestination3.TYPE_ID = new bn_js_1.BN(4, 10);
+    TxDestination3.TYPE_INDEX = new bn_js_1.BN(5, 10);
+    TxDestination3.TYPE_QUANTUM = new bn_js_1.BN(6, 10);
+    TxDestination3.TYPE_LAST = new bn_js_1.BN(6, 10);
   }
 });
 
@@ -10776,7 +10776,7 @@ var require_OptCCParams = __commonJS({
     var TxDestination_1 = require_TxDestination();
     var bn_js_1 = require("bn.js");
     var bufferutils_1 = require_bufferutils();
-    var OptCCParams2 = class _OptCCParams {
+    var OptCCParams3 = class _OptCCParams {
       constructor(data) {
         if (data === null || data === void 0 ? void 0 : data.version)
           this.version = data.version;
@@ -10952,7 +10952,7 @@ var require_OptCCParams = __commonJS({
         return this.internalToBuffer(false);
       }
     };
-    exports2.OptCCParams = OptCCParams2;
+    exports2.OptCCParams = OptCCParams3;
   }
 });
 
@@ -20501,10 +20501,10 @@ var require_tx_destination = __commonJS({
   "node_modules/.pnpm/@bitgo+utxo-lib@https+++codeload.github.com+VerusCoin+BitGoJS+tar.gz+9701df63b479984f27_7b6d2dd0c6d9d9555ac626a4a148d56a/node_modules/@bitgo/utxo-lib/dist/src/tx_destination.js"(exports2, module2) {
     "use strict";
     var varuint = require_varuint_bitcoin();
-    var TxDestination2 = (
+    var TxDestination3 = (
       /** @class */
       (function() {
-        function TxDestination3(destType, destinationBytes) {
+        function TxDestination4(destType, destinationBytes) {
           if (destType === void 0) {
             destType = this.typePKH;
           }
@@ -20514,115 +20514,115 @@ var require_tx_destination = __commonJS({
           this.destType = destType;
           this.destinationBytes = destinationBytes;
         }
-        Object.defineProperty(TxDestination3.prototype, "typeInvalid", {
+        Object.defineProperty(TxDestination4.prototype, "typeInvalid", {
           get: function() {
-            return TxDestination3.TYPE_INVALID;
+            return TxDestination4.TYPE_INVALID;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "typePK", {
+        Object.defineProperty(TxDestination4.prototype, "typePK", {
           get: function() {
-            return TxDestination3.TYPE_PK;
+            return TxDestination4.TYPE_PK;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "isPK", {
+        Object.defineProperty(TxDestination4.prototype, "isPK", {
           get: function() {
             return this.destType === this.typePK;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "typePKH", {
+        Object.defineProperty(TxDestination4.prototype, "typePKH", {
           get: function() {
-            return TxDestination3.TYPE_PKH;
+            return TxDestination4.TYPE_PKH;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "isPKH", {
+        Object.defineProperty(TxDestination4.prototype, "isPKH", {
           get: function() {
             return this.destType === this.typePKH;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "typeSH", {
+        Object.defineProperty(TxDestination4.prototype, "typeSH", {
           get: function() {
-            return TxDestination3.TYPE_SH;
+            return TxDestination4.TYPE_SH;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "isSH", {
+        Object.defineProperty(TxDestination4.prototype, "isSH", {
           get: function() {
             return this.destType === this.typeSH;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "typeID", {
+        Object.defineProperty(TxDestination4.prototype, "typeID", {
           get: function() {
-            return TxDestination3.TYPE_ID;
+            return TxDestination4.TYPE_ID;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "isID", {
+        Object.defineProperty(TxDestination4.prototype, "isID", {
           get: function() {
             return this.destType === this.typeID;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "typeIndex", {
+        Object.defineProperty(TxDestination4.prototype, "typeIndex", {
           get: function() {
-            return TxDestination3.TYPE_INDEX;
+            return TxDestination4.TYPE_INDEX;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "isIndex", {
+        Object.defineProperty(TxDestination4.prototype, "isIndex", {
           get: function() {
             return this.destType === this.typeIndex;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "typeQuantum", {
+        Object.defineProperty(TxDestination4.prototype, "typeQuantum", {
           get: function() {
-            return TxDestination3.TYPE_QUANTUM;
+            return TxDestination4.TYPE_QUANTUM;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "isQuantum", {
+        Object.defineProperty(TxDestination4.prototype, "isQuantum", {
           get: function() {
             return this.destType === this.typeQuantum;
           },
           enumerable: false,
           configurable: true
         });
-        Object.defineProperty(TxDestination3.prototype, "typeLast", {
+        Object.defineProperty(TxDestination4.prototype, "typeLast", {
           get: function() {
-            return TxDestination3.TYPE_QUANTUM;
+            return TxDestination4.TYPE_QUANTUM;
           },
           enumerable: false,
           configurable: true
         });
-        TxDestination3.prototype.isValid = function() {
+        TxDestination4.prototype.isValid = function() {
           return this.destType > this.typeInvalid && this.destType <= this.typeLast && this.destinationBytes && this.destinationBytes.length;
         };
-        TxDestination3.fromChunk = function(chunk) {
+        TxDestination4.fromChunk = function(chunk) {
           var prefix = Buffer.alloc(1);
           prefix.writeUInt8(chunk.length, 0);
-          var dest = new TxDestination3();
+          var dest = new TxDestination4();
           dest.fromBuffer(Buffer.concat([prefix, chunk]));
           return dest;
         };
-        TxDestination3.prototype.fromBuffer = function(buffer, initialOffset) {
+        TxDestination4.prototype.fromBuffer = function(buffer, initialOffset) {
           if (initialOffset === void 0) {
             initialOffset = 0;
           }
@@ -20652,7 +20652,7 @@ var require_tx_destination = __commonJS({
           }
           return offset;
         };
-        TxDestination3.prototype.__byteLength = function() {
+        TxDestination4.prototype.__byteLength = function() {
           if (this.destType === this.typePKH) {
             return 21;
           } else if (this.destType === this.typePK) {
@@ -20661,10 +20661,10 @@ var require_tx_destination = __commonJS({
             return varuint.encodingLength(this.destinationBytes.length + 1) + this.destinationBytes.length + 1;
           }
         };
-        TxDestination3.prototype.toChunk = function() {
+        TxDestination4.prototype.toChunk = function() {
           return this.toBuffer().slice(1);
         };
-        TxDestination3.prototype.toBuffer = function(buffer, initialOffset) {
+        TxDestination4.prototype.toBuffer = function(buffer, initialOffset) {
           if (!buffer)
             buffer = Buffer.allocUnsafe(this.__byteLength());
           var offset = initialOffset || 0;
@@ -20701,17 +20701,17 @@ var require_tx_destination = __commonJS({
             return buffer.slice(initialOffset, offset);
           return buffer.slice(0, offset);
         };
-        TxDestination3.TYPE_INVALID = 0;
-        TxDestination3.TYPE_PK = 1;
-        TxDestination3.TYPE_PKH = 2;
-        TxDestination3.TYPE_SH = 3;
-        TxDestination3.TYPE_ID = 4;
-        TxDestination3.TYPE_INDEX = 5;
-        TxDestination3.TYPE_QUANTUM = 6;
-        return TxDestination3;
+        TxDestination4.TYPE_INVALID = 0;
+        TxDestination4.TYPE_PK = 1;
+        TxDestination4.TYPE_PKH = 2;
+        TxDestination4.TYPE_SH = 3;
+        TxDestination4.TYPE_ID = 4;
+        TxDestination4.TYPE_INDEX = 5;
+        TxDestination4.TYPE_QUANTUM = 6;
+        return TxDestination4;
       })()
     );
-    module2.exports = TxDestination2;
+    module2.exports = TxDestination3;
   }
 });
 
@@ -20879,16 +20879,16 @@ var require_optccparams = __commonJS({
     var bscript = require_script2();
     var EVALS2 = require_evals2();
     var varuint = require_varuint_bitcoin();
-    var TxDestination2 = require_tx_destination();
+    var TxDestination3 = require_tx_destination();
     var bufferutils = require_bufferutils2();
     function varSliceSize(varSlice) {
       var length = varSlice.length;
       return varuint.encodingLength(length) + length;
     }
-    var OptCCParams2 = (
+    var OptCCParams3 = (
       /** @class */
       (function() {
-        function OptCCParams3(version, evalCode, m, n, destinations, serializedObjects) {
+        function OptCCParams4(version, evalCode, m, n, destinations, serializedObjects) {
           if (version === void 0) {
             version = 3;
           }
@@ -20915,7 +20915,7 @@ var require_optccparams = __commonJS({
           this.vData = serializedObjects;
           this.error = null;
         }
-        OptCCParams3.prototype.getParamObject = function() {
+        OptCCParams4.prototype.getParamObject = function() {
           switch (this.evalCode) {
             case EVALS2.EVAL_NONE: {
               return null;
@@ -20949,7 +20949,7 @@ var require_optccparams = __commonJS({
             }
           }
         };
-        OptCCParams3.prototype.isValid = function() {
+        OptCCParams4.prototype.isValid = function() {
           var validEval = false;
           switch (this.evalCode) {
             case EVALS2.EVAL_NONE: {
@@ -20979,17 +20979,17 @@ var require_optccparams = __commonJS({
           }
           return validEval && this.version > 0 && this.version < 4 && (this.version < 3 && this.evalCode < 2 || this.evalCode <= 26 && this.m <= this.n);
         };
-        OptCCParams3.fromChunk = function(chunk) {
+        OptCCParams4.fromChunk = function(chunk) {
           var writer = new bufferutils.BufferWriter(Buffer.alloc(varuint.encodingLength(chunk.length)), 0);
           writer.writeVarInt(chunk.length);
-          var params = new OptCCParams3();
+          var params = new OptCCParams4();
           params.fromBuffer(Buffer.concat([writer.buffer, chunk]));
           return params;
         };
-        OptCCParams3.prototype.toChunk = function() {
+        OptCCParams4.prototype.toChunk = function() {
           return this.toBuffer(void 0, void 0, true);
         };
-        OptCCParams3.prototype.fromBuffer = function(buffer, initialOffset) {
+        OptCCParams4.prototype.fromBuffer = function(buffer, initialOffset) {
           if (initialOffset === void 0) {
             initialOffset = 0;
           }
@@ -21027,7 +21027,7 @@ var require_optccparams = __commonJS({
           this.destinations = [];
           var loop;
           for (loop = 1; this.version && loop < limit; loop++) {
-            var oneDest = TxDestination2.fromChunk(chunks[loop]);
+            var oneDest = TxDestination3.fromChunk(chunks[loop]);
             if (oneDest.isValid()) {
               this.destinations.push(oneDest);
             } else {
@@ -21041,7 +21041,7 @@ var require_optccparams = __commonJS({
           }
           return offset;
         };
-        OptCCParams3.prototype.__byteLength = function() {
+        OptCCParams4.prototype.__byteLength = function() {
           var chunks = [Buffer.allocUnsafe(4)];
           chunks[0][0] = this.version;
           chunks[0][1] = this.evalCode;
@@ -21056,7 +21056,7 @@ var require_optccparams = __commonJS({
           });
           return varSliceSize(bscript.compile(chunks));
         };
-        OptCCParams3.prototype.toBuffer = function(buffer, initialOffset, asChunk) {
+        OptCCParams4.prototype.toBuffer = function(buffer, initialOffset, asChunk) {
           if (asChunk === void 0) {
             asChunk = false;
           }
@@ -21095,10 +21095,10 @@ var require_optccparams = __commonJS({
             return buffer.slice(initialOffset, offset);
           return buffer.slice(0, offset);
         };
-        return OptCCParams3;
+        return OptCCParams4;
       })()
     );
-    module2.exports = OptCCParams2;
+    module2.exports = OptCCParams3;
   }
 });
 
@@ -21110,15 +21110,15 @@ var require_output8 = __commonJS({
     var types = require_types2();
     var typeforce = require_typeforce();
     var OPS = require_bitcoin_ops();
-    var OptCCParams2 = require_optccparams();
+    var OptCCParams3 = require_optccparams();
     var OP_INT_BASE = OPS.OP_RESERVED;
     function check(script2) {
       var chunks = bscript.decompile(script2);
       if (chunks.length < 4 || !(chunks[chunks.length - 1] === OPS.OP_DROP && chunks[1] === OPS.OP_CHECKCRYPTOCONDITION)) {
         return false;
       }
-      var params = OptCCParams2.fromChunk(chunks[2]);
-      var master = OptCCParams2.fromChunk(chunks[0]);
+      var params = OptCCParams3.fromChunk(chunks[2]);
+      var master = OptCCParams3.fromChunk(chunks[0]);
       if (!params.isValid() || !master.isValid()) {
         return false;
       }
@@ -31622,10 +31622,10 @@ var require_smart_transactions = __commonJS({
     var bn_js_1 = require("bn.js");
     var Transaction2 = require_transaction();
     var TransactionBuilder2 = require_transaction_builder();
-    var TxDestination2 = require_tx_destination();
+    var TxDestination3 = require_tx_destination();
     var script2 = require_script2();
     var opcodes2 = require_bitcoin_ops();
-    var OptCCParams2 = require_optccparams();
+    var OptCCParams3 = require_optccparams();
     var templates = require_templates();
     var BNClass = new bn_js_1.BN(0);
     var unpackOutput2 = function(output, systemId, isInput, allowNonTransferEvals) {
@@ -31655,9 +31655,9 @@ var require_smart_transactions = __commonJS({
         var decompiledScript = script2.decompile(outputScript);
         for (var i = 0; i < decompiledScript.length; i += 2) {
           if (i === 0)
-            masterOptCC = OptCCParams2.fromChunk(decompiledScript[i]);
+            masterOptCC = OptCCParams3.fromChunk(decompiledScript[i]);
           else
-            paramsOptCC.push(OptCCParams2.fromChunk(decompiledScript[i]));
+            paramsOptCC.push(OptCCParams3.fromChunk(decompiledScript[i]));
         }
         if (paramsOptCC.length > 1)
           throw new Error(">1 OptCCParam objects not currently supported for smart transaction params.");
@@ -32060,8 +32060,8 @@ var require_smart_transactions = __commonJS({
           var outMaster = void 0;
           var outParams = void 0;
           if (isReserveTransfer) {
-            var destination = new TxDestination2(TxDestination2.TYPE_PKH, verus_typescript_primitives_1.RESERVE_TRANSFER_DESTINATION.destination_bytes);
-            outMaster = new OptCCParams2(3, verus_typescript_primitives_1.EVALS.EVAL_NONE, 1, 1, [destination]);
+            var destination = new TxDestination3(TxDestination3.TYPE_PKH, verus_typescript_primitives_1.RESERVE_TRANSFER_DESTINATION.destination_bytes);
+            outMaster = new OptCCParams3(3, verus_typescript_primitives_1.EVALS.EVAL_NONE, 1, 1, [destination]);
             var flags = new bn_js_1.BN(1);
             var version_1 = new bn_js_1.BN(1, 10);
             var isConversion = params.convertto != null && params.convertto !== params.currency;
@@ -32096,22 +32096,22 @@ var require_smart_transactions = __commonJS({
               second_reserve_id: params.convertto,
               dest_system_id: params.exportto
             });
-            outParams = new OptCCParams2(3, verus_typescript_primitives_1.EVALS.EVAL_RESERVE_TRANSFER, 1, 1, [destination], [resTransfer.toBuffer()]);
+            outParams = new OptCCParams3(3, verus_typescript_primitives_1.EVALS.EVAL_RESERVE_TRANSFER, 1, 1, [destination], [resTransfer.toBuffer()]);
           } else {
             values.value_map.delete(systemId);
             if (values.value_map.size == 0) {
-              var destination = new TxDestination2(params.address.type.toNumber(), params.address.destination_bytes);
-              outMaster = new OptCCParams2(3, verus_typescript_primitives_1.EVALS.EVAL_NONE, 0, 0, []);
-              outParams = new OptCCParams2(3, verus_typescript_primitives_1.EVALS.EVAL_NONE, 1, 1, [destination], []);
+              var destination = new TxDestination3(params.address.type.toNumber(), params.address.destination_bytes);
+              outMaster = new OptCCParams3(3, verus_typescript_primitives_1.EVALS.EVAL_NONE, 0, 0, []);
+              outParams = new OptCCParams3(3, verus_typescript_primitives_1.EVALS.EVAL_NONE, 1, 1, [destination], []);
             } else {
-              var destination = new TxDestination2(params.address.type.toNumber(), params.address.destination_bytes);
-              outMaster = new OptCCParams2(3, verus_typescript_primitives_1.EVALS.EVAL_NONE, 1, 1, [destination]);
+              var destination = new TxDestination3(params.address.type.toNumber(), params.address.destination_bytes);
+              outMaster = new OptCCParams3(3, verus_typescript_primitives_1.EVALS.EVAL_NONE, 1, 1, [destination]);
               var version_2 = new bn_js_1.BN(1, 10);
               var tokenOutput = new verus_typescript_primitives_1.TokenOutput({
                 values,
                 version: version_2
               });
-              outParams = new OptCCParams2(3, verus_typescript_primitives_1.EVALS.EVAL_RESERVE_OUTPUT, 1, 1, [destination], [tokenOutput.toBuffer()]);
+              outParams = new OptCCParams3(3, verus_typescript_primitives_1.EVALS.EVAL_RESERVE_OUTPUT, 1, 1, [destination], [tokenOutput.toBuffer()]);
             }
           }
           var outputScript = script2.compile([
@@ -32213,6 +32213,7 @@ __export(src_exports, {
   AMOUNT_DECIMALS: () => AMOUNT_DECIMALS,
   BASE58_RE: () => BASE58_RE,
   CONSENSUS_BRANCH_ID: () => CONSENSUS_BRANCH_ID,
+  CURRENCY_OPTION: () => CURRENCY_OPTION,
   CURRENCY_TYPE_ORDER: () => CURRENCY_TYPE_ORDER,
   DEFAULT_EXPIRY_DELTA: () => DEFAULT_EXPIRY_DELTA,
   DEFAULT_FEE_PER_KB: () => DEFAULT_FEE_PER_KB,
@@ -32229,6 +32230,8 @@ __export(src_exports, {
   InvalidNameError: () => InvalidNameError,
   InvalidWifError: () => InvalidWifError,
   NETWORK_CONFIG: () => NETWORK_CONFIG,
+  NOTARIZATION_PROTOCOL: () => NOTARIZATION_PROTOCOL,
+  PROOF_PROTOCOL: () => PROOF_PROTOCOL,
   PUBKEY_HASH_PREFIX: () => PUBKEY_HASH_PREFIX,
   RESERVE_TRANSFER_FEE: () => RESERVE_TRANSFER_FEE,
   SATS_PER_COIN: () => SATS_PER_COIN,
@@ -32240,6 +32243,10 @@ __export(src_exports, {
   VerusSDK: () => VerusSDK,
   WIF_PREFIX: () => WIF_PREFIX,
   address: () => address_exports,
+  buildCurrencyDefinitionScript: () => buildCurrencyDefinitionScript,
+  buildCurrencyLaunchOutputs: () => buildCurrencyLaunchOutputs,
+  buildCurrencyLaunchTransaction: () => buildCurrencyLaunchTransaction,
+  buildReserveTransferOutput: () => buildReserveTransferOutput,
   classifyCurrency: () => classifyCurrency,
   currency: () => currency_exports,
   identity: () => public_exports2,
@@ -32252,6 +32259,7 @@ __export(src_exports, {
   message: () => message_exports,
   offers: () => public_exports,
   parseSats: () => parseSats,
+  serializeCurrencyDefinition: () => serializeCurrencyDefinition,
   signing: () => signing_exports,
   toCoins: () => toCoins,
   toSafeNumber: () => toSafeNumber,
@@ -34006,18 +34014,30 @@ function sendCurrency(params, network) {
   const verusNetwork = getNetwork(network === "testnet");
   const systemId = networkConfig.chainId;
   const expiryHeight = resolveExpiryHeight(params.expiryHeight);
-  const txOutputs = params.outputs.map((out) => ({
-    currency: out.currency,
-    satoshis: out.satoshis.toString(10),
-    address: parseAddress2(out.address, out.addressType || "PKH"),
-    ...out.convertTo !== void 0 ? { convertto: out.convertTo } : {},
-    ...out.exportTo !== void 0 ? { exportto: out.exportTo } : {},
-    ...out.via !== void 0 ? { via: out.via } : {},
-    ...out.bridgeId !== void 0 ? { bridgeid: out.bridgeId } : {},
-    ...out.feeCurrency !== void 0 ? { feecurrency: out.feeCurrency } : {},
-    ...out.feeSatoshis !== void 0 ? { feesatoshis: out.feeSatoshis.toString(10) } : {},
-    ...out.preconvert !== void 0 ? { preconvert: out.preconvert } : {}
-  }));
+  for (const out of params.outputs) {
+    if (out.mintnew && (out.convertTo !== void 0 || out.preconvert || out.burn || out.burnweight)) {
+      throw new TransactionBuildError("mintnew cannot be combined with convertTo, preconvert, or burn");
+    }
+  }
+  const txOutputs = params.outputs.map((out) => {
+    const forcesReserveTransfer = out.mintnew || out.burn || out.burnweight;
+    const feecurrency = out.feeCurrency ?? (forcesReserveTransfer ? systemId : void 0);
+    return {
+      currency: out.currency,
+      satoshis: out.satoshis.toString(10),
+      address: parseAddress2(out.address, out.addressType || "PKH"),
+      ...out.convertTo !== void 0 ? { convertto: out.convertTo } : {},
+      ...out.exportTo !== void 0 ? { exportto: out.exportTo } : {},
+      ...out.via !== void 0 ? { via: out.via } : {},
+      ...out.bridgeId !== void 0 ? { bridgeid: out.bridgeId } : {},
+      ...feecurrency !== void 0 ? { feecurrency } : {},
+      ...out.feeSatoshis !== void 0 ? { feesatoshis: out.feeSatoshis.toString(10) } : {},
+      ...out.preconvert !== void 0 ? { preconvert: out.preconvert } : {},
+      ...out.mintnew !== void 0 ? { mintnew: out.mintnew } : {},
+      ...out.burn !== void 0 ? { burn: out.burn } : {},
+      ...out.burnweight !== void 0 ? { burnweight: out.burnweight } : {}
+    };
+  });
   const unfundedTxHex = createUnfundedCurrencyTransfer(
     systemId,
     txOutputs,
@@ -34026,11 +34046,11 @@ function sendCurrency(params, network) {
   );
   const unfundedTx = import_utxo_lib.Transaction.fromHex(unfundedTxHex, verusNetwork);
   const hasSmartOutputs = params.outputs.some(
-    (o) => o.convertTo || o.exportTo || o.via || o.currency !== systemId
+    (o) => o.convertTo || o.exportTo || o.via || o.mintnew || o.burn || o.burnweight || o.currency !== systemId
   );
   const requiredCurrencies = /* @__PURE__ */ new Map();
   for (const out of params.outputs) {
-    if (out.currency !== systemId) {
+    if (out.currency !== systemId && !out.mintnew) {
       requiredCurrencies.set(
         out.currency,
         (requiredCurrencies.get(out.currency) || 0n) + out.satoshis
@@ -34287,9 +34307,18 @@ function verifyMessage(params, network) {
 // src/currency/index.ts
 var currency_exports = {};
 __export(currency_exports, {
+  CURRENCY_DEFINITION_VERSION: () => CURRENCY_DEFINITION_VERSION,
+  CURRENCY_OPTION: () => CURRENCY_OPTION,
   CURRENCY_TYPE_ORDER: () => CURRENCY_TYPE_ORDER,
+  NOTARIZATION_PROTOCOL: () => NOTARIZATION_PROTOCOL,
+  PROOF_PROTOCOL: () => PROOF_PROTOCOL,
+  buildCurrencyDefinitionScript: () => buildCurrencyDefinitionScript,
+  buildCurrencyLaunchOutputs: () => buildCurrencyLaunchOutputs,
+  buildCurrencyLaunchTransaction: () => buildCurrencyLaunchTransaction,
+  buildReserveTransferOutput: () => buildReserveTransferOutput,
   classifyCurrency: () => classifyCurrency,
-  defineCurrency: () => defineCurrency
+  defineCurrency: () => defineCurrency,
+  serializeCurrencyDefinition: () => serializeCurrencyDefinition
 });
 
 // src/currency/classify.ts
@@ -34311,8 +34340,820 @@ function classifyCurrency(currencyInfo) {
   return "token";
 }
 
-// src/currency/index.ts
+// src/currency/wire.ts
 var import_bn3 = __toESM(require("bn.js"));
+var SATOSHIDEN = 100000000n;
+var INT32_MIN = -2147483648;
+var INT32_MAX = 2147483647;
+var ZEROS_32 = Buffer.alloc(32);
+function requireInt32Range(value, label) {
+  if (value < 0n || value > BigInt(INT32_MAX)) {
+    throw new TransactionBuildError(`${label} must be in [0, ${INT32_MAX}], got ${value}`);
+  }
+  return value;
+}
+var INT64_MAX = 2n ** 63n - 1n;
+function requireInt64Range(value, label) {
+  if (value < 0n || value > INT64_MAX) {
+    throw new TransactionBuildError(`${label} must be in [0, 2^63-1], got ${value}`);
+  }
+  return value;
+}
+function uint16LE(value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > 65535) {
+    throw new TransactionBuildError(`${label} must be a uint16, got ${value}`);
+  }
+  const buf = Buffer.alloc(2);
+  buf.writeUInt16LE(value, 0);
+  return buf;
+}
+function int32LE(value, label) {
+  if (!Number.isInteger(value) || value < INT32_MIN || value > INT32_MAX) {
+    throw new TransactionBuildError(`${label} must be an int32, got ${value}`);
+  }
+  const buf = Buffer.alloc(4);
+  buf.writeInt32LE(value, 0);
+  return buf;
+}
+function uint32LE(value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+    throw new TransactionBuildError(`${label} must be a uint32, got ${value}`);
+  }
+  const buf = Buffer.alloc(4);
+  buf.writeUInt32LE(value, 0);
+  return buf;
+}
+function int64LE(value, label) {
+  const buf = Buffer.alloc(8);
+  try {
+    buf.writeBigInt64LE(value, 0);
+  } catch {
+    throw new TransactionBuildError(`${label} does not fit in an int64: ${value}`);
+  }
+  return buf;
+}
+function varInt(value, label) {
+  if (value < 0n) {
+    throw new TransactionBuildError(`${label} must be non-negative for VARINT, got ${value}`);
+  }
+  let n = value;
+  const out = [];
+  let len = 0;
+  for (; ; ) {
+    out.push(Number(n & 0x7fn) | (len > 0 ? 128 : 0));
+    if (n <= 0x7fn) break;
+    n = (n >> 7n) - 1n;
+    len++;
+  }
+  return Buffer.from(out.reverse());
+}
+function limitedString(value, maxLen, label) {
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length > maxLen) {
+    throw new TransactionBuildError(`${label} exceeds ${maxLen} bytes`);
+  }
+  return Buffer.concat([writeCompactSize(bytes.length), bytes]);
+}
+function uint160(iAddress, label) {
+  const hash = iAddressToHash(parseIAddress(iAddress, label));
+  if (hash.length !== 20) {
+    throw new TransactionBuildError(`${label} must be a 20-byte i-address hash`);
+  }
+  return hash;
+}
+function uint160Raw(hash, label) {
+  if (hash.length !== 20) {
+    throw new TransactionBuildError(`${label} must be a 20-byte hash, got ${hash.length}`);
+  }
+  return Buffer.from(hash);
+}
+function uint256Raw(hash, label) {
+  if (hash.length !== 32) {
+    throw new TransactionBuildError(`${label} must be a 32-byte hash, got ${hash.length}`);
+  }
+  return Buffer.from(hash);
+}
+function vectorU160(addresses, label) {
+  return Buffer.concat([
+    writeCompactSize(addresses.length),
+    ...addresses.map((a, i) => uint160(a, `${label}[${i}]`))
+  ]);
+}
+function vectorI64(values, label) {
+  return Buffer.concat([
+    writeCompactSize(values.length),
+    ...values.map((v, i) => int64LE(v, `${label}[${i}]`))
+  ]);
+}
+function vectorI32(values, label) {
+  return Buffer.concat([
+    writeCompactSize(values.length),
+    ...values.map((v, i) => int32LE(Number(v), `${label}[${i}]`))
+  ]);
+}
+function currencyValueMap(entries, label) {
+  return Buffer.concat([
+    writeCompactSize(entries.length),
+    ...entries.flatMap((e, i) => [uint160Raw(e.hash, `${label}[${i}].id`), int64LE(e.amount, `${label}[${i}].amount`)])
+  ]);
+}
+function normalizeWeights(raw) {
+  let total = 0n;
+  for (const w of raw) {
+    if (w <= 0n) {
+      throw new TransactionBuildError(`each reserve weight must be > 0, got ${w}`);
+    }
+    requireInt32Range(w, "weight");
+    total += w;
+  }
+  const out = [];
+  let reserveLeft = SATOSHIDEN;
+  raw.forEach((w, i) => {
+    let amount = SATOSHIDEN * w / total;
+    if (reserveLeft <= amount || i + 1 === raw.length) {
+      amount = reserveLeft;
+    }
+    reserveLeft -= amount;
+    out.push(amount);
+  });
+  return out;
+}
+function toTxDestination(dest) {
+  return dest.kind === "pubkey" ? new boundary_exports.TxDestination(new boundary_exports.PubKey(dest.pubkey, true)) : new boundary_exports.TxDestination(new boundary_exports.KeyID(uint160Raw(dest.hash, "cc destination hash")));
+}
+function wrapCcOutput(evalCode, vdata, dest) {
+  const destination = () => toTxDestination(dest);
+  const master = new boundary_exports.OptCCParams({
+    version: new import_bn3.default(3),
+    eval_code: new import_bn3.default(0),
+    m: new import_bn3.default(1),
+    n: new import_bn3.default(1),
+    destinations: [destination()],
+    vdata: []
+  });
+  const params = new boundary_exports.OptCCParams({
+    version: new import_bn3.default(3),
+    eval_code: new import_bn3.default(evalCode),
+    m: new import_bn3.default(1),
+    n: new import_bn3.default(1),
+    destinations: [destination()],
+    vdata
+  });
+  return import_utxo_lib.script.compile([
+    master.toChunk(),
+    import_utxo_lib.opcodes.OP_CHECKCRYPTOCONDITION,
+    params.toChunk(),
+    import_utxo_lib.opcodes.OP_DROP
+  ]);
+}
+
+// src/currency/definition.ts
+var CURRENCY_DEFINITION_VERSION = 1;
+var CURRENCY_OPTION = {
+  FRACTIONAL: 1,
+  ID_RESTRICTED: 2,
+  ID_STAKING: 4,
+  ID_REFERRALS: 8,
+  ID_REFERRALREQUIRED: 16,
+  TOKEN: 32,
+  SINGLECURRENCY: 64,
+  GATEWAY: 128,
+  PBAAS: 256,
+  GATEWAY_CONVERTER: 512,
+  GATEWAY_NAMECONTROLLER: 1024,
+  NFT_TOKEN: 2048,
+  NO_IDS: 4096
+};
+var NOTARIZATION_PROTOCOL = { AUTO: 1, NOTARY_CONFIRM: 2, NOTARY_CHAINID: 3 };
+var PROOF_PROTOCOL = { PBAASMMR: 1, CHAINID: 2, ETHNOTARIZATION: 3 };
+var CURRENCY_DEFINITION_PUBKEY = Buffer.from(
+  "02a0de91740d3d5a3a4a7990ae22315133d02f33716b339ebce88662d012224ef5",
+  "hex"
+);
+var DEFAULT_ID_REGISTRATION_FEE = 10000000000n;
+var DEFAULT_ID_IMPORT_FEE = 2000000n;
+var DEFAULT_ID_REFERRAL_LEVELS = 3;
+var MIN_RESERVE_RATIO = 5000000n;
+var MAX_RESERVE_CURRENCIES = 10;
+var MAX_ID_REFERRAL_LEVELS = 5;
+var MIN_CURRENCY_LIFE = 480;
+var BLOCK_MAX = 2147483647;
+function normalizeCurrencyDefinition(input) {
+  if (!input.name || input.name.includes("@")) {
+    throw new TransactionBuildError('name must be a bare currency name without "@"');
+  }
+  if (!Number.isInteger(input.options)) {
+    throw new TransactionBuildError("options is required (must include the TOKEN bit)");
+  }
+  if (!(input.options & CURRENCY_OPTION.TOKEN)) {
+    throw new TransactionBuildError("options must include the TOKEN bit (0x20); native currencies are out of scope");
+  }
+  if (input.options & (CURRENCY_OPTION.GATEWAY | CURRENCY_OPTION.PBAAS | CURRENCY_OPTION.GATEWAY_CONVERTER)) {
+    throw new TransactionBuildError("GATEWAY and PBAAS currencies are out of scope for the offline builder");
+  }
+  if (input.options < 0 || input.options > CURRENCY_OPTION.NO_IDS * 2 - 1) {
+    throw new TransactionBuildError(`options has bits outside the known mask: ${input.options}`);
+  }
+  const legacy = input;
+  if (legacy.conversions !== void 0) {
+    throw new TransactionBuildError(
+      "conversions are not supported: a fractional definition always carries a zero conversion vector (the daemon derives launch prices); omit the field"
+    );
+  }
+  if (legacy.initialContributions !== void 0) {
+    throw new TransactionBuildError(
+      "initialContributions are out of scope: they seed reserves the identity must hold and require reserve-deposit inputs the offline builder cannot assemble; contribute via a preconvert reserve-transfer instead"
+    );
+  }
+  const isFractional = Boolean(input.options & CURRENCY_OPTION.FRACTIONAL);
+  const isNFT = Boolean(input.options & CURRENCY_OPTION.NFT_TOKEN);
+  const currencies = input.currencies ?? [];
+  const systemId = input.systemId ?? input.parent;
+  const launchSystemId = input.launchSystemId ?? systemId;
+  if (isNFT) {
+    if (isFractional) {
+      throw new TransactionBuildError("an NFT (NFT_TOKEN) cannot also be FRACTIONAL");
+    }
+    if (currencies.length || input.weights?.length) {
+      throw new TransactionBuildError("do not set currencies/weights for an NFT \u2014 the system currency is added automatically");
+    }
+    if (input.minPreconversion || input.maxPreconversion) {
+      throw new TransactionBuildError("do not set min/maxPreconversion for an NFT \u2014 they are fixed (maxPreconversion=[0])");
+    }
+    if ((input.initialSupply ?? 0n) !== 0n || (input.preLaunchDiscount ?? 0n) !== 0n) {
+      throw new TransactionBuildError("an NFT takes no initialSupply or preLaunchDiscount \u2014 its supply is the single 1-satoshi token");
+    }
+    if ((input.preLaunchCarveOut ?? 0) !== 0) {
+      throw new TransactionBuildError("an NFT takes no preLaunchCarveOut");
+    }
+    const proofProtocol = input.proofProtocol ?? PROOF_PROTOCOL.PBAASMMR;
+    if (proofProtocol === PROOF_PROTOCOL.CHAINID) {
+      throw new TransactionBuildError("an NFT may not use a centralized proof protocol (CHAINID/2); use PBAASMMR (1)");
+    }
+    const preAllocations = input.preAllocations ?? [];
+    const preallocTotal = preAllocations.reduce((sum, p) => sum + p.amount, 0n);
+    if (preallocTotal !== 1n) {
+      throw new TransactionBuildError("an NFT must pre-allocate exactly 1 satoshi \u2014 the single indivisible token");
+    }
+    return {
+      version: CURRENCY_DEFINITION_VERSION,
+      options: input.options,
+      parent: input.parent,
+      name: input.name,
+      launchSystemId,
+      systemId,
+      notarizationProtocol: input.notarizationProtocol ?? NOTARIZATION_PROTOCOL.AUTO,
+      proofProtocol,
+      startBlock: input.startBlock ?? 0,
+      endBlock: input.endBlock ?? 0,
+      initialFractionalSupply: 0n,
+      preAllocations,
+      gatewayConverterIssuance: 0n,
+      // The daemon maps the NFT to the native/system currency with a zeroed
+      // conversion and maxPreconvert=[0]; weights stay empty (not fractional).
+      currencies: [systemId],
+      weights: [],
+      conversions: [0n],
+      minPreconversion: [],
+      maxPreconversion: [0n],
+      initialContributions: [0n],
+      preconverted: [0n],
+      preLaunchDiscount: 0n,
+      preLaunchCarveOut: 0,
+      notaries: [],
+      minNotariesConfirm: 0,
+      idRegistrationFees: input.idRegistrationFees ?? DEFAULT_ID_REGISTRATION_FEE,
+      idReferralLevels: input.idReferralLevels ?? DEFAULT_ID_REFERRAL_LEVELS,
+      idImportFees: input.idImportFees ?? DEFAULT_ID_IMPORT_FEE
+    };
+  }
+  if (isFractional && currencies.length === 0) {
+    throw new TransactionBuildError("a fractional currency requires at least one reserve currency");
+  }
+  if (!isFractional && currencies.length > 0) {
+    throw new TransactionBuildError("reserve currencies require the FRACTIONAL bit (0x01)");
+  }
+  let fractionalWeights = [];
+  if (isFractional) {
+    if (input.weights === void 0 || input.weights.length !== currencies.length) {
+      throw new TransactionBuildError(`a fractional currency requires one weight per reserve currency (${currencies.length})`);
+    }
+    if ((input.initialSupply ?? 0n) <= 0n) {
+      throw new TransactionBuildError("a fractional currency requires a positive initialSupply (the daemon rejects zero)");
+    }
+    if (currencies.length > MAX_RESERVE_CURRENCIES) {
+      throw new TransactionBuildError(`a fractional currency may have at most ${MAX_RESERVE_CURRENCIES} reserve currencies, got ${currencies.length}`);
+    }
+    if (!currencies.includes(systemId)) {
+      throw new TransactionBuildError(`a fractional currency must include the chain's native currency (${systemId}) among its reserves`);
+    }
+    fractionalWeights = normalizeWeights(input.weights);
+    fractionalWeights.forEach((w, i) => {
+      if (w < MIN_RESERVE_RATIO) {
+        throw new TransactionBuildError(`reserve weight[${i}] normalizes to ${w}, below the 5% minimum (${MIN_RESERVE_RATIO}); a fractional reserve may not go below 5%`);
+      }
+    });
+  } else {
+    if (input.initialSupply !== void 0 && input.initialSupply !== 0n) {
+      throw new TransactionBuildError("initialSupply applies only to a FRACTIONAL currency");
+    }
+    if (input.preLaunchDiscount !== void 0 && input.preLaunchDiscount !== 0n) {
+      throw new TransactionBuildError("preLaunchDiscount applies only to a FRACTIONAL currency");
+    }
+  }
+  const requireBlock = (v, label) => {
+    if (!Number.isInteger(v) || v < 0 || v > BLOCK_MAX) {
+      throw new TransactionBuildError(`${label} must be an integer block height in [0, ${BLOCK_MAX}], got ${v}`);
+    }
+  };
+  const startBlock = input.startBlock ?? 0;
+  const endBlock = input.endBlock ?? 0;
+  requireBlock(startBlock, "startBlock");
+  requireBlock(endBlock, "endBlock");
+  if (endBlock !== 0 && endBlock < startBlock + MIN_CURRENCY_LIFE) {
+    throw new TransactionBuildError(`endBlock (${endBlock}) must be 0 or \u2265 startBlock + ${MIN_CURRENCY_LIFE} (${startBlock + MIN_CURRENCY_LIFE})`);
+  }
+  if ((input.idReferralLevels ?? DEFAULT_ID_REFERRAL_LEVELS) > MAX_ID_REFERRAL_LEVELS) {
+    throw new TransactionBuildError(`idReferralLevels must be \u2264 ${MAX_ID_REFERRAL_LEVELS}`);
+  }
+  if ((input.preLaunchCarveOut ?? 0) < 0) {
+    throw new TransactionBuildError("preLaunchCarveOut must be non-negative");
+  }
+  (input.preAllocations ?? []).forEach((p, i) => {
+    if (p.amount <= 0n) {
+      throw new TransactionBuildError(`preAllocations[${i}].amount must be positive, got ${p.amount}`);
+    }
+  });
+  const checkVec = (arr, label) => {
+    if (arr.length !== currencies.length) {
+      throw new TransactionBuildError(`${label} must have one entry per reserve currency (${currencies.length}), got ${arr.length}`);
+    }
+    arr.forEach((v, i) => {
+      if (v < 0n) throw new TransactionBuildError(`${label}[${i}] must be non-negative, got ${v}`);
+    });
+    return arr;
+  };
+  const emptyOr = (arr, label) => arr === void 0 ? [] : checkVec(arr, label);
+  const zeros = () => new Array(currencies.length).fill(0n);
+  const minPreconversion = emptyOr(input.minPreconversion, "minPreconversion");
+  const maxPreconversion = emptyOr(input.maxPreconversion, "maxPreconversion");
+  if (minPreconversion.length && maxPreconversion.length) {
+    for (let i = 0; i < currencies.length; i++) {
+      const min = minPreconversion[i];
+      const max = maxPreconversion[i];
+      if (min !== void 0 && max !== void 0 && max < min) {
+        throw new TransactionBuildError(
+          `maxPreconversion[${i}] (${max}) must be \u2265 minPreconversion[${i}] (${min})`
+        );
+      }
+    }
+  }
+  return {
+    version: CURRENCY_DEFINITION_VERSION,
+    options: input.options,
+    parent: input.parent,
+    name: input.name,
+    launchSystemId,
+    systemId,
+    notarizationProtocol: input.notarizationProtocol ?? NOTARIZATION_PROTOCOL.AUTO,
+    proofProtocol: input.proofProtocol ?? PROOF_PROTOCOL.CHAINID,
+    startBlock: input.startBlock ?? 0,
+    endBlock: input.endBlock ?? 0,
+    initialFractionalSupply: input.initialSupply ?? 0n,
+    preAllocations: input.preAllocations ?? [],
+    gatewayConverterIssuance: 0n,
+    currencies,
+    // Normalized to sum to 1e8 (computed and range-checked above).
+    weights: fractionalWeights,
+    // A fractional definition always carries a zero conversion vector (the daemon
+    // ignores any explicit `conversions` and derives launch prices); a
+    // non-fractional token has no reserves, hence an empty vector.
+    conversions: zeros(),
+    minPreconversion,
+    maxPreconversion,
+    // `initialContributions` and `preconverted` are internal to a fresh
+    // definition: both carry a zero per reserve currency (empty for a
+    // non-fractional token). Matches on-chain definitions.
+    initialContributions: zeros(),
+    preconverted: zeros(),
+    preLaunchDiscount: requireInt32Range(input.preLaunchDiscount ?? 0n, "preLaunchDiscount"),
+    preLaunchCarveOut: input.preLaunchCarveOut ?? 0,
+    notaries: [],
+    minNotariesConfirm: 0,
+    idRegistrationFees: requireInt64Range(input.idRegistrationFees ?? DEFAULT_ID_REGISTRATION_FEE, "idRegistrationFees"),
+    idReferralLevels: input.idReferralLevels ?? DEFAULT_ID_REFERRAL_LEVELS,
+    idImportFees: requireInt64Range(input.idImportFees ?? DEFAULT_ID_IMPORT_FEE, "idImportFees")
+  };
+}
+var MAX_NAME_LEN = 64;
+function serializeNormalizedDefinition(def) {
+  const parts = [
+    uint32LE(def.version, "version"),
+    uint32LE(def.options, "options"),
+    uint160(def.parent, "parent"),
+    limitedString(def.name, MAX_NAME_LEN, "name"),
+    uint160(def.launchSystemId, "launchSystemId"),
+    uint160(def.systemId, "systemId"),
+    int32LE(def.notarizationProtocol, "notarizationProtocol"),
+    int32LE(def.proofProtocol, "proofProtocol"),
+    // nativeCurrencyID: a null CTransferDestination (type 0, empty destination) → `0000`.
+    Buffer.from([0, 0]),
+    // gatewayID: null uint160 for a non-gateway currency → 20 zero bytes.
+    Buffer.alloc(20),
+    varInt(BigInt(def.startBlock), "startBlock"),
+    varInt(BigInt(def.endBlock), "endBlock"),
+    int64LE(def.initialFractionalSupply, "initialSupply"),
+    // preAllocation: CompactSize count, then (uint160 recipient, int64 amount) pairs.
+    writeCompactSize(def.preAllocations.length),
+    ...def.preAllocations.flatMap((p, i) => [
+      uint160(p.address, `preAllocations[${i}].address`),
+      int64LE(p.amount, `preAllocations[${i}].amount`)
+    ]),
+    int64LE(def.gatewayConverterIssuance, "gatewayConverterIssuance"),
+    vectorU160(def.currencies, "currencies"),
+    vectorI32(def.weights, "weights"),
+    vectorI64(def.conversions, "conversions"),
+    vectorI64(def.minPreconversion, "minPreconversion"),
+    vectorI64(def.maxPreconversion, "maxPreconversion"),
+    vectorI64(def.initialContributions, "initialContributions"),
+    vectorI64(def.preconverted, "preconverted"),
+    varInt(def.preLaunchDiscount, "preLaunchDiscount"),
+    int32LE(def.preLaunchCarveOut, "preLaunchCarveOut"),
+    vectorU160(def.notaries, "notaries"),
+    varInt(BigInt(def.minNotariesConfirm), "minNotariesConfirm"),
+    varInt(def.idRegistrationFees, "idRegistrationFees"),
+    varInt(BigInt(def.idReferralLevels), "idReferralLevels"),
+    varInt(def.idImportFees, "idImportFees")
+  ];
+  return Buffer.concat(parts);
+}
+var EVAL_CURRENCY_DEFINITION = 2;
+function serializeCurrencyDefinition(input) {
+  return serializeNormalizedDefinition(normalizeCurrencyDefinition(input));
+}
+function buildCurrencyDefinitionScript(input) {
+  const defBytes = serializeNormalizedDefinition(normalizeCurrencyDefinition(input));
+  return wrapCcOutput(EVAL_CURRENCY_DEFINITION, [defBytes], {
+    kind: "pubkey",
+    pubkey: CURRENCY_DEFINITION_PUBKEY
+  }).toString("hex");
+}
+
+// src/currency/outputs.ts
+var import_bn4 = __toESM(require("bn.js"));
+var EVAL_CROSSCHAIN_IMPORT = 13;
+var EVAL_ACCEPTEDNOTARIZATION = 5;
+var EVAL_CROSSCHAIN_EXPORT = 12;
+var EVAL_RESERVE_DEPOSIT = 11;
+var CC_PUBKEY = {
+  [EVAL_ACCEPTEDNOTARIZATION]: "02d85f078815b7a52faa92639c3691d2a640e26c4e06de54dd1490f0e93bcc11c3",
+  [EVAL_CROSSCHAIN_EXPORT]: "02cbfe54fb371cfc89d35b46cafcad6ac3b7dc9b40546b0f30b2b29a4865ed3b4a",
+  [EVAL_RESERVE_DEPOSIT]: "03b99d7cb946c5b1f8a54cde49b8d7e0a2a15a22639feb798009f82b519526c050"
+};
+var CC_IMPORT_KEYHASH = Buffer.from("6e4ae35cca122eb65e73abd4c956940ef25a3eab", "hex");
+var IDENTITY_FLAG_ACTIVECURRENCY2 = 1;
+var IDENTITY_FLAG_TOKENIZED_ID_CONTROL = 4;
+function pubkeyDest(evalCode) {
+  return { kind: "pubkey", pubkey: Buffer.from(CC_PUBKEY[evalCode], "hex") };
+}
+function buildIdentityUpdateOutput(identityJson, options) {
+  const identity = boundary_exports.Identity.fromJson(identityJson);
+  if (identity.flags.and(new import_bn4.default(IDENTITY_FLAG_ACTIVECURRENCY2)).gtn(0)) {
+    throw new TransactionBuildError("identity already has an active currency (FLAG_ACTIVECURRENCY set); a currency can be defined only once per identity");
+  }
+  identity.flags = identity.flags.or(new import_bn4.default(IDENTITY_FLAG_ACTIVECURRENCY2));
+  if (options & CURRENCY_OPTION.NFT_TOKEN) {
+    identity.flags = identity.flags.or(new import_bn4.default(IDENTITY_FLAG_TOKENIZED_ID_CONTROL));
+  }
+  return { script: buildIdentityScript(identity).toString("hex"), value: 0n };
+}
+function serializeImport(systemHash, currencyHash, exportTxOutNum, height) {
+  return Buffer.concat([
+    uint16LE(1, "import.version"),
+    uint16LE(9, "import.flags"),
+    // DEFINITION_IMPORT(1) | SAME_CHAIN(8)
+    uint160Raw(systemHash, "import.sourceSystemID"),
+    uint32LE(height, "import.sourceSystemHeight"),
+    uint160Raw(currencyHash, "import.importCurrencyID"),
+    currencyValueMap([], "import.importValue"),
+    currencyValueMap([], "import.totalReserveOutMap"),
+    int32LE(0, "import.numOutputs"),
+    uint256Raw(ZEROS_32, "import.hashReserveTransfers"),
+    uint256Raw(ZEROS_32, "import.exportTxId"),
+    int32LE(exportTxOutNum, "import.exportTxOutNum")
+  ]);
+}
+function serializeCoinbaseCurrencyState(currencyHash, reserveHashes, normalizedWeights, isFractional, initialFractionalSupply, tokenSupply) {
+  const n = reserveHashes.length;
+  const zeroVec = () => Buffer.concat([writeCompactSize(n), ...Array.from({ length: n }, () => int64LE(0n, "state.zero"))]);
+  const supply = isFractional ? initialFractionalSupply : tokenSupply;
+  const stateWeights = normalizedWeights.length === n ? normalizedWeights : new Array(n).fill(0n);
+  const parts = [
+    uint16LE(1, "state.version"),
+    uint16LE(isFractional ? 3 : 2, "state.flags"),
+    // PRELAUNCH(2) [| FRACTIONAL(1)]
+    uint160Raw(currencyHash, "state.currencyID"),
+    writeCompactSize(n),
+    ...reserveHashes.map((h, i) => uint160Raw(h, `state.currencies[${i}]`)),
+    writeCompactSize(n),
+    ...stateWeights.map((w, i) => int32LE(Number(w), `state.weights[${i}]`)),
+    zeroVec(),
+    // reserves — zero at definition (no preconversions yet)
+    varInt(isFractional ? initialFractionalSupply : 0n, "state.initialSupply"),
+    varInt(0n, "state.emitted"),
+    varInt(supply, "state.supply"),
+    // CCoinbaseCurrencyState extension — all-zero at definition.
+    int64LE(0n, "state.primaryCurrencyOut"),
+    int64LE(0n, "state.preConvertedOut"),
+    int64LE(0n, "state.primaryCurrencyFees"),
+    int64LE(0n, "state.primaryCurrencyConversionFees"),
+    zeroVec(),
+    // reserveIn
+    zeroVec(),
+    // primaryCurrencyIn
+    zeroVec(),
+    // reserveOut
+    // conversionPrice (Bancor, reserves→SATOSHIDEN substitution)
+    writeCompactSize(n),
+    ...stateWeights.map((w, i) => {
+      const price = isFractional && initialFractionalSupply > 0n && w > 0n ? SATOSHIDEN * SATOSHIDEN * SATOSHIDEN / (initialFractionalSupply * w) : 0n;
+      return int64LE(price, `state.conversionPrice[${i}]`);
+    }),
+    zeroVec(),
+    // viaConversionPrice
+    zeroVec(),
+    // fees
+    // priorWeights — zero at definition (int32 vector, one per reserve).
+    writeCompactSize(n),
+    ...stateWeights.map((_, i) => int32LE(0, `state.priorWeights[${i}]`)),
+    zeroVec()
+    // conversionFees
+  ];
+  return Buffer.concat(parts);
+}
+function serializeNotarization(currencyHash, currencyState, height) {
+  return Buffer.concat([
+    varInt(2n, "notarization.version"),
+    // CPBaaSNotarization::VERSION_CURRENT on VRSC/VRSCTEST
+    varInt(0x83n, "notarization.flags"),
+    // DEF_NOTARIZATION(1) | PRE_LAUNCH(2) | SAME_CHAIN(0x80)
+    Buffer.from([0, 0]),
+    // proposer: empty CTransferDestination
+    uint160Raw(currencyHash, "notarization.currencyID"),
+    currencyState,
+    uint32LE(height, "notarization.notarizationHeight"),
+    uint256Raw(ZEROS_32, "notarization.prevNotarization.hash"),
+    uint32LE(4294967295, "notarization.prevNotarization.n"),
+    uint256Raw(ZEROS_32, "notarization.hashPrevCrossNotarization"),
+    uint32LE(0, "notarization.prevHeight"),
+    writeCompactSize(0),
+    // currencyStates map (empty) — version ≥ 2
+    writeCompactSize(0),
+    // proofRoots map (empty)   — version ≥ 2
+    writeCompactSize(0)
+    // nodes vector (empty)
+  ]);
+}
+function serializeExport(systemHash, currencyHash, height, fee) {
+  return Buffer.concat([
+    uint16LE(1, "export.version"),
+    uint16LE(65, "export.flags"),
+    // DEFINITION_EXPORT(0x40) | PRELAUNCH(1)
+    uint160Raw(systemHash, "export.sourceSystemID"),
+    uint256Raw(ZEROS_32, "export.hashReserveTransfers"),
+    uint160Raw(systemHash, "export.destSystemID"),
+    // same chain
+    uint160Raw(currencyHash, "export.destCurrencyID"),
+    Buffer.from([0, 0]),
+    // exporter: empty CTransferDestination
+    int32LE(-1, "export.firstInput"),
+    int32LE(0, "export.numInputs"),
+    varInt(0n, "export.sourceHeightStart"),
+    varInt(BigInt(height), "export.sourceHeightEnd"),
+    currencyValueMap(fee, "export.totalFees"),
+    currencyValueMap(fee, "export.totalAmounts"),
+    currencyValueMap([], "export.totalBurned"),
+    writeCompactSize(0)
+    // reserveTransfers (empty)
+  ]);
+}
+function serializeReserveDeposit(systemHash, controllingHash, amount) {
+  return Buffer.concat([
+    varInt(1n, "reserveDeposit.version"),
+    uint160Raw(systemHash, "reserveDeposit.currencyID"),
+    varInt(amount, "reserveDeposit.amount"),
+    uint160Raw(controllingHash, "reserveDeposit.controllingCurrencyID")
+  ]);
+}
+function buildIdentityChangeScript(identityHash) {
+  const master = Buffer.from([4, 3, 0, 0, 0]);
+  const idDest = Buffer.concat([Buffer.from([21, 4]), identityHash]);
+  const params = Buffer.concat([Buffer.from([4, 3, 0, 1, 1]), idDest]);
+  return Buffer.concat([
+    Buffer.from([master.length]),
+    master,
+    Buffer.from([204]),
+    // OP_CHECKCRYPTOCONDITION
+    Buffer.from([params.length]),
+    params,
+    Buffer.from([117])
+    // OP_DROP
+  ]);
+}
+function buildCurrencyLaunchOutputs(input, context) {
+  const def = normalizeCurrencyDefinition(input);
+  const identityAddress = context.identity.identityaddress;
+  if (typeof identityAddress !== "string" || !identityAddress) {
+    throw new TransactionBuildError("context.identity.identityaddress is required");
+  }
+  const derivedId = deriveIdentityAddress(def.name, def.parent);
+  if (derivedId !== identityAddress) {
+    throw new TransactionBuildError(
+      `identity mismatch: currency "${def.name}" under ${def.parent} derives ${derivedId}, but context.identity.identityaddress is ${identityAddress}`
+    );
+  }
+  if (!Number.isInteger(context.height) || context.height < 0) {
+    throw new TransactionBuildError(`context.height must be a non-negative block height, got ${context.height}`);
+  }
+  if (def.startBlock <= context.height) {
+    throw new TransactionBuildError(`startBlock (${def.startBlock}) must be greater than the current height (${context.height})`);
+  }
+  if (typeof context.identity.systemid === "string" && def.systemId !== context.identity.systemid) {
+    throw new TransactionBuildError(`currency systemId (${def.systemId}) must equal the chain system id (${String(context.identity.systemid)})`);
+  }
+  if (context.launchFeeSats <= 0n) {
+    throw new TransactionBuildError("context.launchFeeSats must be positive");
+  }
+  const systemHash = iAddressToHash(def.systemId);
+  const currencyHash = iAddressToHash(identityAddress);
+  const reserveHashes = def.currencies.map((c) => iAddressToHash(c));
+  const isFractional = Boolean(def.options & CURRENCY_OPTION.FRACTIONAL);
+  const importFee = context.launchFeeSats - context.launchFeeSats / 2n;
+  const tokenSupply = def.preAllocations.reduce((sum, p) => sum + p.amount, 0n);
+  const feeEntry = [{ hash: systemHash, amount: importFee }];
+  const identityUpdate = buildIdentityUpdateOutput(context.identity, def.options);
+  const currencyDefinition = {
+    script: buildCurrencyDefinitionScript(input),
+    value: 0n
+  };
+  const importOutput = {
+    // exportTxOutNum = 4 points at the export output (same tx).
+    script: wrapCcOutput(EVAL_CROSSCHAIN_IMPORT, [serializeImport(systemHash, currencyHash, 4, context.height)], {
+      kind: "keyid",
+      hash: CC_IMPORT_KEYHASH
+    }).toString("hex"),
+    value: 0n
+  };
+  const currencyState = serializeCoinbaseCurrencyState(
+    currencyHash,
+    reserveHashes,
+    def.weights,
+    isFractional,
+    def.initialFractionalSupply,
+    tokenSupply
+  );
+  const notarization = {
+    script: wrapCcOutput(
+      EVAL_ACCEPTEDNOTARIZATION,
+      [serializeNotarization(currencyHash, currencyState, context.height)],
+      pubkeyDest(EVAL_ACCEPTEDNOTARIZATION)
+    ).toString("hex"),
+    value: 0n
+  };
+  const exportOutput = {
+    script: wrapCcOutput(
+      EVAL_CROSSCHAIN_EXPORT,
+      [serializeExport(systemHash, currencyHash, context.height, feeEntry)],
+      pubkeyDest(EVAL_CROSSCHAIN_EXPORT)
+    ).toString("hex"),
+    value: 0n
+  };
+  const reserveDeposit = {
+    script: wrapCcOutput(
+      EVAL_RESERVE_DEPOSIT,
+      [serializeReserveDeposit(systemHash, currencyHash, importFee)],
+      pubkeyDest(EVAL_RESERVE_DEPOSIT)
+    ).toString("hex"),
+    value: importFee
+  };
+  const change = {
+    script: buildIdentityChangeScript(currencyHash).toString("hex"),
+    value: 0n
+  };
+  const ordered = [identityUpdate, currencyDefinition, importOutput, notarization, exportOutput, reserveDeposit, change];
+  return { identityUpdate, currencyDefinition, import: importOutput, notarization, export: exportOutput, reserveDeposit, change, ordered };
+}
+
+// src/currency/launch.ts
+function buildCurrencyLaunchTransaction(params, network) {
+  const wifCheck = validateWif(params.wif);
+  if (!wifCheck.valid) {
+    throw new InvalidWifError(wifCheck.error);
+  }
+  if (!params.fundingUtxos || params.fundingUtxos.length === 0) {
+    throw new TransactionBuildError("at least one funding UTXO is required");
+  }
+  const identityAddress = params.identity.identityaddress;
+  if (typeof identityAddress !== "string" || !identityAddress) {
+    throw new TransactionBuildError("identity.identityaddress is required");
+  }
+  const chainId = NETWORK_CONFIG[network].chainId;
+  const systemId = params.definition.systemId ?? params.definition.parent;
+  if (systemId !== chainId) {
+    throw new TransactionBuildError(`currency systemId/parent (${systemId}) must be the chain id (${chainId}) \u2014 this SDK launches same-chain currencies only`);
+  }
+  const verusNetwork = getNetwork(network === "testnet");
+  assertWifIsPrimary(params.wif, boundary_exports.Identity.fromJson(params.identity), verusNetwork);
+  const outputs = buildCurrencyLaunchOutputs(params.definition, {
+    identity: params.identity,
+    height: params.height,
+    launchFeeSats: params.launchFeeSats
+  });
+  const consensusOutputs = outputs.ordered.slice(0, 6).map((o) => ({
+    script: Buffer.from(o.script, "hex"),
+    nativeSat: o.value
+  }));
+  const extraOutputBytes = consensusOutputs.reduce((sum, o) => sum + o.script.length, 0);
+  const assembled = assembleFundedIdentityUpdate({
+    network,
+    wif: params.wif,
+    // Default to a bounded expiry above the tip (matching the doc), NOT 0, which
+    // would silently make the transaction never expire. Pass expiryHeight: 0
+    // explicitly to opt into a never-expiring transaction.
+    expiryHeight: params.expiryHeight ?? params.height + DEFAULT_EXPIRY_DELTA,
+    funding: params.fundingUtxos,
+    identityUtxo: params.identityUtxo,
+    outputs: consensusOutputs,
+    changeAddress: params.changeAddress ?? identityAddress,
+    extraOutputBytes,
+    label: "currency launch"
+  });
+  return {
+    signedTx: assembled.signedTx,
+    txid: assembled.txid,
+    fee: assembled.fee,
+    nativeChange: assembled.nativeChange,
+    inputsUsed: assembled.inputsUsed,
+    currencyAddress: identityAddress
+  };
+}
+
+// src/currency/reserveTransfer.ts
+var import_bn5 = __toESM(require("bn.js"));
+var EVAL_RESERVE_TRANSFER = 8;
+var RESERVE_TRANSFER_KEYHASH = Buffer.from("cb8a0f7f651b484a81e2312c3438deb601e27368", "hex");
+var MIN_TRANSFER_FEE = 20000n;
+var RT_VALID = 1;
+var RT_CONVERT = 2;
+var RT_PRECONVERT = 4;
+var DEST_ID3 = 4;
+var FLAG_DEST_AUX = 64;
+function buildReserveTransferOutput(params) {
+  if (params.amount <= 0n) {
+    throw new TransactionBuildError("amount must be positive");
+  }
+  if (params.feeAmount < MIN_TRANSFER_FEE) {
+    throw new TransactionBuildError(`feeAmount must be at least ${MIN_TRANSFER_FEE} (the daemon's minimum transfer fee), got ${params.feeAmount}`);
+  }
+  parseIAddress(params.sourceCurrency, "sourceCurrency");
+  parseIAddress(params.destCurrency, "destCurrency");
+  parseIAddress(params.recipient, "recipient");
+  if (params.refundAddress !== void 0) {
+    parseIAddress(params.refundAddress, "refundAddress");
+  }
+  const feeCurrency = params.feeCurrency ?? params.sourceCurrency;
+  parseIAddress(feeCurrency, "feeCurrency");
+  if (feeCurrency !== params.sourceCurrency) {
+    throw new TransactionBuildError("feeCurrency must equal sourceCurrency (this builder handles native-reserve transfers only)");
+  }
+  const flags = RT_VALID | RT_CONVERT | (params.preconvert ? RT_PRECONVERT : 0);
+  const transfer2 = new boundary_exports.ReserveTransfer({
+    // Single-value mode (multivalue:false) — the daemon's encoding for a
+    // single-currency transfer: currency id + VARINT amount, no count prefix.
+    values: new boundary_exports.CurrencyValueMap({
+      value_map: /* @__PURE__ */ new Map([[params.sourceCurrency, new import_bn5.default(params.amount.toString())]]),
+      multivalue: false
+    }),
+    version: new import_bn5.default(1),
+    flags: new import_bn5.default(flags),
+    fee_currency_id: feeCurrency,
+    fee_amount: new import_bn5.default(params.feeAmount.toString()),
+    transfer_destination: boundary_exports.TransferDestination.fromJson({
+      type: DEST_ID3 | FLAG_DEST_AUX,
+      address: params.recipient,
+      auxdests: [{ type: DEST_ID3, address: params.refundAddress ?? params.recipient }]
+    }),
+    dest_currency_id: params.destCurrency
+  });
+  const script2 = wrapCcOutput(EVAL_RESERVE_TRANSFER, [transfer2.toBuffer()], {
+    kind: "keyid",
+    hash: RESERVE_TRANSFER_KEYHASH
+  }).toString("hex");
+  return { script: script2, value: params.amount + params.feeAmount };
+}
+
+// src/currency/index.ts
+var import_bn6 = __toESM(require("bn.js"));
 function defineCurrency(params, network) {
   const wifCheck = validateWif(params.wif);
   if (!wifCheck.valid) {
@@ -34327,6 +35168,7 @@ function defineCurrency(params, network) {
   if (!params.currencyDefScript) {
     throw new TransactionBuildError("currencyDefScript is required");
   }
+  const currencyDefScriptHex = params.currencyDefScript;
   const verusNetwork = getNetwork(network === "testnet");
   const currencyDefValue = params.currencyDefValue || 0n;
   const identity = new boundary_exports.Identity();
@@ -34334,11 +35176,11 @@ function defineCurrency(params, network) {
   assertWifIsPrimary(params.wif, identity, verusNetwork);
   if (!identity.hasActiveCurrency()) {
     const currentFlags = identity.flags.toNumber();
-    identity.flags = new import_bn3.default(currentFlags | IDENTITY_FLAG_ACTIVECURRENCY);
+    identity.flags = new import_bn6.default(currentFlags | IDENTITY_FLAG_ACTIVECURRENCY);
   }
   const identityScript = boundary_exports.IdentityScript.fromIdentity(identity);
   const identityOutputScript = identityScript.toBuffer();
-  const currencyDefScript = Buffer.from(params.currencyDefScript, "hex");
+  const currencyDefScript = Buffer.from(currencyDefScriptHex, "hex");
   const assembled = assembleFundedIdentityUpdate({
     network,
     wif: params.wif,
@@ -35151,10 +35993,47 @@ var VerusSDK = class {
     );
   }
   // ─── Currency ──────────────────────────────────────
-  /** Define a new currency (manual mode — pre-built script) */
+  /**
+   * Assemble the identity-spend + currency-definition output for a currency.
+   *
+   * A partial helper — NOT a full launch. For a complete, broadcastable launch
+   * built entirely offline (all seven outputs), use
+   * {@link VerusSDK.buildCurrencyLaunchTransaction}. To build only the definition
+   * output script, use {@link VerusSDK.buildCurrencyDefinitionScript}.
+   */
   defineCurrency(params) {
     return defineCurrency(params, this.network);
   }
+  /**
+   * Serialize a currency definition (token or fractional basket) to its
+   * EVAL_CURRENCY_DEFINITION output script — offline, byte-equivalent to the
+   * daemon's `definecurrency`. For building/inspecting/verifying the definition
+   * script; a full on-chain launch is a daemon operation (see `defineCurrency`).
+   */
+  buildCurrencyDefinitionScript(input) {
+    return buildCurrencyDefinitionScript(input);
+  }
+  /**
+   * Build all seven output scripts of a currency-definition transaction offline,
+   * byte-equivalent to `definecurrency` — identity update, currency definition,
+   * import, notarization (with currency state), export, reserve deposit, and
+   * change. Needs the defining identity (from a lite node's `getidentity`), the
+   * current chain tip height, and the chain's currency launch fee. Produces the
+   * output scripts; funding, the identity input, and signing are assembled
+   * separately (see `CurrencyLaunchContext`).
+   */
+  buildCurrencyLaunchOutputs(input, context) {
+    return buildCurrencyLaunchOutputs(input, context);
+  }
+  /**
+   * Build and sign a full, broadcastable currency-definition transaction offline:
+   * the seven byte-locked outputs, funded from the supplied UTXOs, with the
+   * defining identity spent under primary authority. Hand the signed hex to any
+   * node to launch the currency. See `CurrencyLaunchTxParams`.
+   */
+  buildCurrencyLaunchTransaction(params) {
+    return buildCurrencyLaunchTransaction(params, this.network);
+  }
   // ─── Message Signing ───────────────────────────────
   /** Sign a message with a VerusID identity signature */
   signMessage(params) {
@@ -35282,6 +36161,7 @@ __export(public_exports2, {
   AMOUNT_DECIMALS,
   BASE58_RE,
   CONSENSUS_BRANCH_ID,
+  CURRENCY_OPTION,
   CURRENCY_TYPE_ORDER,
   DEFAULT_EXPIRY_DELTA,
   DEFAULT_FEE_PER_KB,
@@ -35298,6 +36178,8 @@ __export(public_exports2, {
   InvalidNameError,
   InvalidWifError,
   NETWORK_CONFIG,
+  NOTARIZATION_PROTOCOL,
+  PROOF_PROTOCOL,
   PUBKEY_HASH_PREFIX,
   RESERVE_TRANSFER_FEE,
   SATS_PER_COIN,
@@ -35309,6 +36191,10 @@ __export(public_exports2, {
   VerusSDK,
   WIF_PREFIX,
   address,
+  buildCurrencyDefinitionScript,
+  buildCurrencyLaunchOutputs,
+  buildCurrencyLaunchTransaction,
+  buildReserveTransferOutput,
   classifyCurrency,
   currency,
   identity,
@@ -35321,6 +36207,7 @@ __export(public_exports2, {
   message,
   offers,
   parseSats,
+  serializeCurrencyDefinition,
   signing,
   toCoins,
   toSafeNumber,