@chainvue/verus-sdk 0.10.0 → 0.11.0

package/dist/bundle.js

@@ -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 Identity3 = class _Identity extends Principal_1.Principal {
+    var Identity4 = 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 = Identity3;
-    Identity3.VERSION_INVALID = new bn_js_1.BN(0);
-    Identity3.VERSION_VERUSID = new bn_js_1.BN(1);
-    Identity3.VERSION_VAULT = new bn_js_1.BN(2);
-    Identity3.VERSION_PBAAS = new bn_js_1.BN(3);
-    Identity3.VERSION_CURRENT = Identity3.VERSION_PBAAS;
-    Identity3.VERSION_FIRSTVALID = new bn_js_1.BN(1);
-    Identity3.VERSION_LASTVALID = new bn_js_1.BN(3);
+    exports2.Identity = Identity4;
+    Identity4.VERSION_INVALID = new bn_js_1.BN(0);
+    Identity4.VERSION_VERUSID = new bn_js_1.BN(1);
+    Identity4.VERSION_VAULT = new bn_js_1.BN(2);
+    Identity4.VERSION_PBAAS = new bn_js_1.BN(3);
+    Identity4.VERSION_CURRENT = Identity4.VERSION_PBAAS;
+    Identity4.VERSION_FIRSTVALID = new bn_js_1.BN(1);
+    Identity4.VERSION_LASTVALID = new bn_js_1.BN(3);
   }
 });
 
@@ -20226,10 +20226,10 @@ var require_smart_transaction_signature = __commonJS({
     "use strict";
     var Buffer2 = require_safe_buffer().Buffer;
     var varuint = require_varuint_bitcoin();
-    var SmartTransactionSignature = (
+    var SmartTransactionSignature2 = (
       /** @class */
       (function() {
-        function SmartTransactionSignature2(version, sigType, pubKeyData, oneSignature) {
+        function SmartTransactionSignature3(version, sigType, pubKeyData, oneSignature) {
           if (version === void 0) {
             version = 1;
           }
@@ -20244,7 +20244,7 @@ var require_smart_transaction_signature = __commonJS({
             this.oneSignature = new Buffer2(0);
           }
         }
-        SmartTransactionSignature2.prototype.fromBuffer = function(buffer, initialOffset) {
+        SmartTransactionSignature3.prototype.fromBuffer = function(buffer, initialOffset) {
           var offset = initialOffset || 0;
           function readSlice(n) {
             offset += n;
@@ -20268,10 +20268,10 @@ var require_smart_transaction_signature = __commonJS({
           this.oneSignature = readVarSlice();
           return offset;
         };
-        SmartTransactionSignature2.prototype.__byteLength = function() {
+        SmartTransactionSignature3.prototype.__byteLength = function() {
           return 1 + varuint.encodingLength(this.pubKeyData.length) + this.pubKeyData.length + varuint.encodingLength(this.oneSignature.length) + this.oneSignature.length;
         };
-        SmartTransactionSignature2.prototype.toBuffer = function(buffer, initialOffset) {
+        SmartTransactionSignature3.prototype.toBuffer = function(buffer, initialOffset) {
           var noBuffer = !buffer;
           if (noBuffer)
             buffer = Buffer2.allocUnsafe(this.__byteLength());
@@ -20297,10 +20297,10 @@ var require_smart_transaction_signature = __commonJS({
             return noBuffer ? buffer.slice(initialOffset, offset) : offset;
           return noBuffer ? buffer.slice(0, offset) : offset;
         };
-        return SmartTransactionSignature2;
+        return SmartTransactionSignature3;
       })()
     );
-    module2.exports = SmartTransactionSignature;
+    module2.exports = SmartTransactionSignature2;
   }
 });
 
@@ -20311,11 +20311,11 @@ var require_smart_transaction_signatures = __commonJS({
     var Buffer2 = require_safe_buffer().Buffer;
     var bscript = require_script2();
     var varuint = require_varuint_bitcoin();
-    var SmartTransactionSignature = require_smart_transaction_signature();
-    var SmartTransactionSignatures = (
+    var SmartTransactionSignature2 = require_smart_transaction_signature();
+    var SmartTransactionSignatures2 = (
       /** @class */
       (function() {
-        function SmartTransactionSignatures2(version, sigHashType, signatures) {
+        function SmartTransactionSignatures3(version, sigHashType, signatures) {
           if (version === void 0) {
             version = 1;
           }
@@ -20327,19 +20327,19 @@ var require_smart_transaction_signatures = __commonJS({
           this.signatures = signatures || [];
           this.error = null;
         }
-        SmartTransactionSignatures2.prototype.isValid = function() {
+        SmartTransactionSignatures3.prototype.isValid = function() {
           return this.version > 0 && this.version < 2 && bscript.isDefinedHashType(this.sigHashType) && this.signatures.length > 0;
         };
-        SmartTransactionSignatures2.prototype.__byteLength = function() {
+        SmartTransactionSignatures3.prototype.__byteLength = function() {
           return this.signatures.reduce(function(a, x) {
             return a + x.__byteLength();
           }, 2 + varuint.encodingLength(this.signatures.length));
         };
-        SmartTransactionSignatures2.prototype.minLength = function() {
-          var checkSigs = new SmartTransactionSignatures2();
+        SmartTransactionSignatures3.prototype.minLength = function() {
+          var checkSigs = new SmartTransactionSignatures3();
           return checkSigs.__byteLength();
         };
-        SmartTransactionSignatures2.prototype.toBuffer = function(buffer, initialOffset) {
+        SmartTransactionSignatures3.prototype.toBuffer = function(buffer, initialOffset) {
           var noBuffer = !buffer;
           if (noBuffer)
             buffer = Buffer2.allocUnsafe(this.__byteLength());
@@ -20361,15 +20361,15 @@ var require_smart_transaction_signatures = __commonJS({
             return noBuffer ? buffer.slice(initialOffset, offset) : offset;
           return noBuffer ? buffer.slice(0, offset) : offset;
         };
-        SmartTransactionSignatures2.fromChunk = function(chunk) {
-          var sigs = new SmartTransactionSignatures2();
+        SmartTransactionSignatures3.fromChunk = function(chunk) {
+          var sigs = new SmartTransactionSignatures3();
           sigs.fromBuffer(chunk);
           return sigs;
         };
-        SmartTransactionSignatures2.prototype.toChunk = function() {
+        SmartTransactionSignatures3.prototype.toChunk = function() {
           return this.toBuffer();
         };
-        SmartTransactionSignatures2.prototype.fromBuffer = function(buffer, initialOffset) {
+        SmartTransactionSignatures3.prototype.fromBuffer = function(buffer, initialOffset) {
           if (initialOffset === void 0) {
             initialOffset = 0;
           }
@@ -20385,7 +20385,7 @@ var require_smart_transaction_signatures = __commonJS({
             return vi;
           }
           function readOneSig() {
-            var oneSig = new SmartTransactionSignature();
+            var oneSig = new SmartTransactionSignature2();
             offset = oneSig.fromBuffer(buffer, offset);
             return oneSig;
           }
@@ -20410,10 +20410,10 @@ var require_smart_transaction_signatures = __commonJS({
           }
           return offset;
         };
-        return SmartTransactionSignatures2;
+        return SmartTransactionSignatures3;
       })()
     );
-    module2.exports = SmartTransactionSignatures;
+    module2.exports = SmartTransactionSignatures2;
   }
 });
 
@@ -20424,7 +20424,7 @@ var require_input7 = __commonJS({
     var bscript = require_script2();
     var typeforce = require_typeforce();
     var OPS = require_bitcoin_ops();
-    var SmartTransactionSignatures = require_smart_transaction_signatures();
+    var SmartTransactionSignatures2 = require_smart_transaction_signatures();
     function partialSignature(value) {
       return value === OPS.OP_0 || bscript.isCanonicalSignature(value);
     }
@@ -20432,13 +20432,13 @@ var require_input7 = __commonJS({
       var chunks = bscript.decompile(script2);
       if (chunks.length !== 1)
         return false;
-      return SmartTransactionSignatures.fromChunk(chunks[0]).isValid();
+      return SmartTransactionSignatures2.fromChunk(chunks[0]).isValid();
     }
     check.toJSON = function() {
       return "smart transaction input";
     };
     function encodeStack(signature) {
-      var smartTxSigs = SmartTransactionSignatures.fromChunk(signature);
+      var smartTxSigs = SmartTransactionSignatures2.fromChunk(signature);
       if (smartTxSigs.error == null)
         return [signature];
       else
@@ -30150,8 +30150,8 @@ var require_transaction_builder = __commonJS({
     var ECPair2 = require_ecpair();
     var ECSignature = require_ecsignature();
     var Transaction2 = require_transaction();
-    var SmartTransactionSignatures = require_smart_transaction_signatures();
-    var SmartTransactionSignature = require_smart_transaction_signature();
+    var SmartTransactionSignatures2 = require_smart_transaction_signatures();
+    var SmartTransactionSignature2 = require_smart_transaction_signature();
     var getMainnet = require_coins().getMainnet;
     var debug = require_src()("bitgo:utxolib:txbuilder");
     function supportedType(type) {
@@ -30594,7 +30594,7 @@ var require_transaction_builder = __commonJS({
         if (input.prevOutType === scriptTypes.SMART_TRANSACTION) {
           if (input.signatures === void 0 || input.signatures.length === 0)
             return true;
-          var smartTxSigs = SmartTransactionSignatures.fromChunk(bscript.decompile(input.signatures)[0]);
+          var smartTxSigs = SmartTransactionSignatures2.fromChunk(bscript.decompile(input.signatures)[0]);
           if (smartTxSigs.error != null || smartTxSigs.signatures.length === 0 || smartTxSigs.signatures.every(function(sig) {
             return sig.oneSignature.length === 0;
           })) {
@@ -30822,8 +30822,8 @@ var require_transaction_builder = __commonJS({
           signature = ECSignature.fromRSBuffer(signature);
         debug("Produced signature (r: %s, s: %s)", signature.r, signature.s);
         if (input.signType === scriptTypes.SMART_TRANSACTION) {
-          input.signatures[i] = new SmartTransactionSignatures(1, 1, [
-            new SmartTransactionSignature(1, 1, pubKey, signature.toCompact().slice(1))
+          input.signatures[i] = new SmartTransactionSignatures2(1, 1, [
+            new SmartTransactionSignature2(1, 1, pubKey, signature.toCompact().slice(1))
           ]).toChunk();
         } else
           input.signatures[i] = signature.toScriptSignature(hashType);
@@ -30854,7 +30854,7 @@ var require_transaction_builder = __commonJS({
         if (input.signatures === void 0)
           return true;
         if (input.signType === scriptTypes.SMART_TRANSACTION) {
-          var smartTxSigs = SmartTransactionSignatures.fromChunk(bscript.decompile(input.signatures)[0]);
+          var smartTxSigs = SmartTransactionSignatures2.fromChunk(bscript.decompile(input.signatures)[0]);
           if (smartTxSigs.error != null || smartTxSigs.signatures.length === 0 || smartTxSigs.signatures.every(function(sig) {
             return sig.oneSignature.length === 0;
           })) {
@@ -32242,13 +32242,14 @@ __export(src_exports, {
   address: () => address_exports,
   classifyCurrency: () => classifyCurrency,
   currency: () => currency_exports,
-  identity: () => public_exports,
+  identity: () => public_exports2,
   isIAddress: () => isIAddress2,
   isIdentityName: () => isIdentityName,
   isRAddress: () => isRAddress2,
   isVerusAddress: () => isVerusAddress,
   keys: () => keys_exports,
   message: () => message_exports,
+  offers: () => public_exports,
   parseSats: () => parseSats,
   signing: () => signing_exports,
   toCoins: () => toCoins,
@@ -32275,6 +32276,8 @@ var boundary_exports = {};
 __export(boundary_exports, {
   ECPair: () => import_utxo_lib.ECPair,
   IdentitySignature: () => import_utxo_lib.IdentitySignature,
+  SmartTransactionSignature: () => import_utxo_lib.SmartTransactionSignature,
+  SmartTransactionSignatures: () => import_utxo_lib.SmartTransactionSignatures,
   Transaction: () => import_utxo_lib.Transaction,
   TransactionBuilder: () => import_utxo_lib.TransactionBuilder,
   address: () => import_utxo_lib.address,
@@ -32649,6 +32652,7 @@ __export(utxo_exports, {
   assertTokenConservation: () => assertTokenConservation,
   decodeUtxo: () => decodeUtxo,
   estimateFee: () => estimateFee,
+  isSmartTransactionScript: () => isSmartTransactionScript,
   selectUtxos: () => selectUtxos
 });
 var { unpackOutput } = import_utxo_lib.smarttxs;
@@ -33184,6 +33188,19 @@ function buildCommitmentScript(commitmentHashBuf, controlAddress) {
   const script2 = new boundary_exports.SmartTransactionScript(master, params);
   return script2.toBuffer();
 }
+var OFFER_TOKEN_COMMITMENT_MARKER = Buffer.concat([
+  Buffer.from("2767181a4f6abe2090a7dca2c689477d163900f6", "hex"),
+  Buffer.alloc(12, 0)
+]);
+function buildTokenCommitmentScript(offeredCurrency, amountSat, controlAddress) {
+  const values = new boundary_exports.CurrencyValueMap({
+    value_map: /* @__PURE__ */ new Map([[offeredCurrency, new import_bn.default(amountSat.toString(10))]]),
+    multivalue: false
+  });
+  const tokenOutput = new boundary_exports.TokenOutput({ version: new import_bn.default(1), values });
+  const vdata = Buffer.concat([OFFER_TOKEN_COMMITMENT_MARKER, tokenOutput.toBuffer()]);
+  return buildCommitmentScript(vdata, controlAddress);
+}
 function buildReservationScript(newIdentityIAddress, serializedReservation, isAdvanced = false) {
   const identityDest = new boundary_exports.TxDestination(boundary_exports.IdentityID.fromAddress(newIdentityIAddress));
   const evalCode = isAdvanced ? EVAL_IDENTITY_ADVANCEDRESERVATION : boundary_exports.EVALS.EVAL_IDENTITY_RESERVATION;
@@ -34347,6 +34364,451 @@ function defineCurrency(params, network) {
   };
 }
 
+// src/offers/public.ts
+var public_exports = {};
+__export(public_exports, {
+  buildBuyIdentityOffer: () => buildBuyIdentityOffer,
+  buildOffer: () => buildOffer,
+  buildOfferFunding: () => buildOfferFunding,
+  buildSellIdentityOffer: () => buildSellIdentityOffer,
+  buildSwapIdentityOffer: () => buildSwapIdentityOffer,
+  completeBuyIdentityOffer: () => completeBuyIdentityOffer,
+  completeOffer: () => completeOffer,
+  completeSellIdentityOffer: () => completeSellIdentityOffer,
+  completeSwapIdentityOffer: () => completeSwapIdentityOffer
+});
+
+// src/offers/sign.ts
+var SIGHASH_SINGLE = 3;
+var SIGHASH_ANYONECANPAY = 128;
+var SIGHASH_OFFER = SIGHASH_SINGLE | SIGHASH_ANYONECANPAY;
+function signOfferInput(unsignedHex, inputIndex, prevOutScript, prevOutValue, wif, network) {
+  const verusNetwork = getNetwork(network === "testnet");
+  const tx = import_utxo_lib.Transaction.fromHex(unsignedHex, verusNetwork);
+  const input = tx.ins[inputIndex];
+  if (!input) {
+    throw new TransactionBuildError(`signOfferInput: no input at index ${inputIndex}`);
+  }
+  const keyPair = import_utxo_lib.ECPair.fromWIF(wif, verusNetwork);
+  const sighash = tx.hashForSignatureByNetwork(
+    inputIndex,
+    prevOutScript,
+    toSafeNumber(prevOutValue),
+    SIGHASH_OFFER,
+    false
+  );
+  const signature = keyPair.sign(sighash);
+  const fulfillment = new import_utxo_lib.SmartTransactionSignatures(1, SIGHASH_OFFER, [
+    new import_utxo_lib.SmartTransactionSignature(1, 1, keyPair.getPublicKeyBuffer(), signature.toCompact().slice(1))
+  ]).toChunk();
+  input.script = import_utxo_lib.script.compile([fulfillment]);
+  return { signedTx: tx.toHex(), txid: tx.getId() };
+}
+function signTakerInputs(txHex, takerInputs, wif, network) {
+  const verusNetwork = getNetwork(network === "testnet");
+  const tx = import_utxo_lib.Transaction.fromHex(txHex, verusNetwork);
+  const keyPair = import_utxo_lib.ECPair.fromWIF(wif, verusNetwork);
+  for (const { index, prevOutScript, value } of takerInputs) {
+    const input = tx.ins[index];
+    if (!input) {
+      throw new TransactionBuildError(`signTakerInputs: no input at index ${index}`);
+    }
+    const sighash = tx.hashForSignatureByNetwork(
+      index,
+      prevOutScript,
+      toSafeNumber(value),
+      import_utxo_lib.Transaction.SIGHASH_ALL,
+      false
+    );
+    const signature = keyPair.sign(sighash);
+    input.script = isSmartTransactionScript(prevOutScript) ? import_utxo_lib.script.compile([
+      new import_utxo_lib.SmartTransactionSignatures(1, import_utxo_lib.Transaction.SIGHASH_ALL, [
+        new import_utxo_lib.SmartTransactionSignature(1, 1, keyPair.getPublicKeyBuffer(), signature.toCompact().slice(1))
+      ]).toChunk()
+    ]) : import_utxo_lib.script.compile([signature.toScriptSignature(import_utxo_lib.Transaction.SIGHASH_ALL), keyPair.getPublicKeyBuffer()]);
+  }
+  return { signedTx: tx.toHex(), txid: tx.getId() };
+}
+
+// src/offers/maker.ts
+function buildOfferFunding(params, network) {
+  if (params.offered.amount <= 0n) {
+    throw new TransactionBuildError("offered.amount must be positive");
+  }
+  const makerAddress = parseRAddress(params.makerAddress, "makerAddress");
+  const systemId = NETWORK_CONFIG[network].chainId;
+  const offeringNative = params.offered.currency === systemId;
+  const commitmentScript = offeringNative ? buildCommitmentScript(Buffer.alloc(32, 0), makerAddress) : buildTokenCommitmentScript(params.offered.currency, params.offered.amount, makerAddress);
+  const commitmentOutput = offeringNative ? { script: commitmentScript, nativeSat: params.offered.amount } : {
+    script: commitmentScript,
+    nativeSat: 0n,
+    carries: /* @__PURE__ */ new Map([[params.offered.currency, params.offered.amount]])
+  };
+  const assembled = assembleAndSign({
+    network,
+    wif: params.wif,
+    expiryHeight: params.expiryHeight ?? 0,
+    funding: params.utxos,
+    outputs: [commitmentOutput],
+    changeAddress: params.changeAddress,
+    fee: { policy: "estimate" },
+    label: "offer funding"
+  });
+  return {
+    fundingTx: assembled.signedTx,
+    txid: assembled.txid,
+    fee: assembled.fee,
+    commitment: {
+      txid: assembled.txid,
+      vout: 0,
+      // Native satoshis on the commitment output — 0 for a token offer. This is
+      // the amount the offer input signs over (SIGHASH_SINGLE|ANYONECANPAY).
+      value: offeringNative ? params.offered.amount : 0n,
+      script: commitmentScript.toString("hex")
+    }
+  };
+}
+function buildOffer(params, network) {
+  const verusNetwork = getNetwork(network === "testnet");
+  const systemId = NETWORK_CONFIG[network].chainId;
+  if (params.want.amount <= 0n) {
+    throw new TransactionBuildError("want.amount must be positive");
+  }
+  if (params.expiryHeight === void 0 || !Number.isInteger(params.expiryHeight) || params.expiryHeight <= 0) {
+    throw new TransactionBuildError(
+      "expiryHeight (a positive future block height) is required for an offer; the daemon rejects a 0/never-expiring offer as expired. Use currentBlockHeight + a margin (e.g. +200)."
+    );
+  }
+  let wantedScript;
+  let wantedNative;
+  if (params.want.currency === systemId) {
+    wantedScript = params.want.address.startsWith("i") ? identityPaymentScript(parseIAddress(params.want.address, "want.address")) : addressToScriptPubKey(params.want.address);
+    wantedNative = params.want.amount;
+  } else {
+    wantedScript = buildTokenChangeOutput(
+      parseAddress(params.want.address, "want.address"),
+      /* @__PURE__ */ new Map([[params.want.currency, params.want.amount]])
+    ).script;
+    wantedNative = 0n;
+  }
+  const txb = new import_utxo_lib.TransactionBuilder(verusNetwork);
+  txb.setVersion(4);
+  txb.setExpiryHeight(resolveExpiryHeight(params.expiryHeight));
+  txb.setVersionGroupId(VERSION_GROUP_ID);
+  txb.addInput(
+    Buffer.from(params.commitment.txid, "hex").reverse(),
+    params.commitment.vout,
+    4294967295,
+    Buffer.from(params.commitment.script, "hex")
+  );
+  txb.addOutput(wantedScript, toSafeNumber(wantedNative));
+  const unsignedHex = txb.buildIncomplete().toHex();
+  const { signedTx, txid } = signOfferInput(
+    unsignedHex,
+    0,
+    Buffer.from(params.commitment.script, "hex"),
+    params.commitment.value,
+    params.wif,
+    network
+  );
+  return { offerTx: signedTx, txid };
+}
+
+// src/offers/taker.ts
+function nativePaymentScript(address2) {
+  return address2.startsWith("i") ? identityPaymentScript(parseIAddress(address2, "address")) : addressToScriptPubKey(address2);
+}
+function completeOffer(params, network) {
+  const verusNetwork = getNetwork(network === "testnet");
+  const systemId = NETWORK_CONFIG[network].chainId;
+  const offeringNative = params.offered.currency === systemId;
+  const wantingNative = params.want.currency === systemId;
+  if (params.offered.amount <= 0n || params.want.amount <= 0n) {
+    throw new TransactionBuildError("completeOffer: offered.amount and want.amount must be positive");
+  }
+  const tx = import_utxo_lib.Transaction.fromHex(params.offerTx, verusNetwork);
+  if (tx.ins.length !== 1 || tx.outs.length !== 1) {
+    throw new TransactionBuildError("completeOffer: expected a maker offer partial (1 input, 1 output)");
+  }
+  const commitmentNative = offeringNative ? params.offered.amount : 0n;
+  if (offeringNative) {
+    tx.addOutput(nativePaymentScript(params.takerAddress), toSafeNumber(params.offered.amount));
+  } else {
+    const offeredOut = buildTokenChangeOutput(
+      parseAddress(params.takerAddress, "takerAddress"),
+      /* @__PURE__ */ new Map([[params.offered.currency, params.offered.amount]])
+    );
+    tx.addOutput(offeredOut.script, 0);
+  }
+  const wantedTokenReq = wantingNative ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map([[params.want.currency, params.want.amount]]);
+  const requiredNative = wantingNative ? params.want.amount : 0n;
+  const selection = selectUtxos(
+    params.takerUtxos,
+    requiredNative,
+    wantedTokenReq,
+    3,
+    systemId,
+    void 0,
+    true,
+    150
+  );
+  const takerInputs = [];
+  for (const u of selection.selected) {
+    const idx = tx.addInput(Buffer.from(u.txid, "hex").reverse(), u.outputIndex, 4294967295);
+    takerInputs.push({ index: idx, prevOutScript: Buffer.from(u.script, "hex"), value: u.satoshis });
+  }
+  const hasTokenChange = selection.currencyChanges.size > 0;
+  if (hasTokenChange || selection.nativeChange > 0n) {
+    if (hasTokenChange) {
+      const change = buildTokenChangeOutput(parseAddress(params.changeAddress, "changeAddress"), selection.currencyChanges);
+      tx.addOutput(change.script, toSafeNumber(selection.nativeChange));
+    } else {
+      tx.addOutput(nativePaymentScript(params.changeAddress), toSafeNumber(selection.nativeChange));
+    }
+  }
+  assertTokenConservation(
+    selection.selected,
+    wantedTokenReq,
+    selection.currencyChanges,
+    systemId,
+    "takeOffer"
+  );
+  const takerNativeIn = selection.selected.reduce((s, u) => s + u.satoshis, 0n);
+  const allInputsNative = commitmentNative + takerNativeIn;
+  assertNativeConservation([{ satoshis: allInputsNative }], tx.outs, selection.fee, "takeOffer");
+  const { signedTx, txid } = signTakerInputs(tx.toHex(), takerInputs, params.wif, network);
+  return { swapTx: signedTx, txid };
+}
+
+// src/offers/identity.ts
+function nativePaymentScript2(address2) {
+  return address2.startsWith("i") ? identityPaymentScript(parseIAddress(address2, "address")) : addressToScriptPubKey(address2);
+}
+function buildTransferredIdentity(identityJson, newPrimaryAddresses) {
+  const identity = boundary_exports.Identity.fromJson(identityJson);
+  identity.setPrimaryAddresses(newPrimaryAddresses);
+  return buildIdentityScript(identity);
+}
+function assertExpiryHeight(expiryHeight) {
+  if (!Number.isInteger(expiryHeight) || expiryHeight <= 0) {
+    throw new TransactionBuildError(
+      "expiryHeight (a positive future block height) is required for an offer; the daemon rejects a 0/never-expiring offer as expired."
+    );
+  }
+}
+function fundFeeAndSignIdentityTaker(args) {
+  const systemId = NETWORK_CONFIG[args.network].chainId;
+  const verusNetwork = getNetwork(args.network === "testnet");
+  const selection = selectUtxos(args.takerUtxos, 0n, /* @__PURE__ */ new Map(), 3, systemId, void 0, true, args.extraOutputBytes);
+  if (selection.currencyChanges.size > 0) {
+    throw new TransactionBuildError(
+      `${args.label}: the fee UTXOs must carry only the native coin; a token-bearing UTXO was selected and its reserve value would be lost.`
+    );
+  }
+  const expectedScript = addressToScriptPubKey(
+    import_utxo_lib.ECPair.fromWIF(args.wif, verusNetwork).getAddress()
+  ).toString("hex");
+  const takerInputs = [...args.priorInputs];
+  for (const u of selection.selected) {
+    if (!isSmartTransactionScript(Buffer.from(u.script, "hex")) && u.script !== expectedScript) {
+      throw new TransactionBuildError(
+        `${args.label}: fee UTXO ${u.txid}:${u.outputIndex} is not controlled by the provided wif (its scriptPubKey does not match the wif's address).`
+      );
+    }
+    const idx = args.tx.addInput(Buffer.from(u.txid, "hex").reverse(), u.outputIndex, 4294967295);
+    takerInputs.push({ index: idx, prevOutScript: Buffer.from(u.script, "hex"), value: u.satoshis });
+  }
+  if (selection.nativeChange > 0n) {
+    args.tx.addOutput(nativePaymentScript2(args.changeAddress), toSafeNumber(selection.nativeChange));
+  }
+  const feeNativeIn = selection.selected.reduce((s, u) => s + u.satoshis, 0n);
+  assertNativeConservation(
+    [{ satoshis: args.extraInputNative + feeNativeIn }],
+    args.tx.outs,
+    selection.fee,
+    args.label
+  );
+  const { signedTx, txid } = signTakerInputs(args.tx.toHex(), takerInputs, args.wif, args.network);
+  return { swapTx: signedTx, txid };
+}
+function buildSellIdentityOffer(params, network) {
+  const commitment = {
+    txid: params.identityOutput.txid,
+    vout: params.identityOutput.vout,
+    value: 0n,
+    // an identity primary output carries 0 native
+    script: params.identityOutput.script
+  };
+  return buildOffer({ wif: params.wif, commitment, want: params.want, expiryHeight: params.expiryHeight }, network);
+}
+function completeSellIdentityOffer(params, network) {
+  const verusNetwork = getNetwork(network === "testnet");
+  const systemId = NETWORK_CONFIG[network].chainId;
+  const wantingNative = params.want.currency === systemId;
+  if (params.want.amount <= 0n) {
+    throw new TransactionBuildError("completeSellIdentityOffer: want.amount must be positive");
+  }
+  if (params.newPrimaryAddresses.length === 0) {
+    throw new TransactionBuildError("completeSellIdentityOffer: newPrimaryAddresses must not be empty");
+  }
+  const tx = import_utxo_lib.Transaction.fromHex(params.offerTx, verusNetwork);
+  if (tx.ins.length !== 1 || tx.outs.length !== 1) {
+    throw new TransactionBuildError("completeSellIdentityOffer: expected a maker offer partial (1 input, 1 output)");
+  }
+  tx.addOutput(buildTransferredIdentity(params.identityJson, params.newPrimaryAddresses), 0);
+  const wantedTokenReq = wantingNative ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map([[params.want.currency, params.want.amount]]);
+  const requiredNative = wantingNative ? params.want.amount : 0n;
+  const selection = selectUtxos(
+    params.takerUtxos,
+    requiredNative,
+    wantedTokenReq,
+    3,
+    systemId,
+    void 0,
+    true,
+    150
+  );
+  const takerInputs = [];
+  for (const u of selection.selected) {
+    const idx = tx.addInput(Buffer.from(u.txid, "hex").reverse(), u.outputIndex, 4294967295);
+    takerInputs.push({ index: idx, prevOutScript: Buffer.from(u.script, "hex"), value: u.satoshis });
+  }
+  const hasTokenChange = selection.currencyChanges.size > 0;
+  if (hasTokenChange || selection.nativeChange > 0n) {
+    if (hasTokenChange) {
+      const change = buildTokenChangeOutput(parseAddress(params.changeAddress, "changeAddress"), selection.currencyChanges);
+      tx.addOutput(change.script, toSafeNumber(selection.nativeChange));
+    } else {
+      tx.addOutput(nativePaymentScript2(params.changeAddress), toSafeNumber(selection.nativeChange));
+    }
+  }
+  assertTokenConservation(selection.selected, wantedTokenReq, selection.currencyChanges, systemId, "takeSellIdentityOffer");
+  const takerNativeIn = selection.selected.reduce((s, u) => s + u.satoshis, 0n);
+  assertNativeConservation([{ satoshis: takerNativeIn }], tx.outs, selection.fee, "takeSellIdentityOffer");
+  const { signedTx, txid } = signTakerInputs(tx.toHex(), takerInputs, params.wif, network);
+  return { swapTx: signedTx, txid };
+}
+function buildBuyIdentityOffer(params, network) {
+  assertExpiryHeight(params.expiryHeight);
+  if (params.buyerPrimaryAddresses.length === 0) {
+    throw new TransactionBuildError("buildBuyIdentityOffer: buyerPrimaryAddresses must not be empty");
+  }
+  const verusNetwork = getNetwork(network === "testnet");
+  const wantedScript = buildTransferredIdentity(params.identityJson, params.buyerPrimaryAddresses);
+  const txb = new import_utxo_lib.TransactionBuilder(verusNetwork);
+  txb.setVersion(4);
+  txb.setExpiryHeight(resolveExpiryHeight(params.expiryHeight));
+  txb.setVersionGroupId(VERSION_GROUP_ID);
+  txb.addInput(
+    Buffer.from(params.commitment.txid, "hex").reverse(),
+    params.commitment.vout,
+    4294967295,
+    Buffer.from(params.commitment.script, "hex")
+  );
+  txb.addOutput(wantedScript, 0);
+  const { signedTx, txid } = signOfferInput(
+    txb.buildIncomplete().toHex(),
+    0,
+    Buffer.from(params.commitment.script, "hex"),
+    params.commitment.value,
+    params.wif,
+    network
+  );
+  return { offerTx: signedTx, txid };
+}
+function completeBuyIdentityOffer(params, network) {
+  const verusNetwork = getNetwork(network === "testnet");
+  const systemId = NETWORK_CONFIG[network].chainId;
+  const offeringNative = params.offered.currency === systemId;
+  if (params.offered.amount <= 0n) {
+    throw new TransactionBuildError("completeBuyIdentityOffer: offered.amount must be positive");
+  }
+  const tx = import_utxo_lib.Transaction.fromHex(params.offerTx, verusNetwork);
+  if (tx.ins.length !== 1 || tx.outs.length !== 1) {
+    throw new TransactionBuildError("completeBuyIdentityOffer: expected a maker offer partial (1 input, 1 output)");
+  }
+  const commitmentNative = offeringNative ? params.offered.amount : 0n;
+  const idIdx = tx.addInput(
+    Buffer.from(params.identityOutput.txid, "hex").reverse(),
+    params.identityOutput.vout,
+    4294967295
+  );
+  const takerInputs = [
+    { index: idIdx, prevOutScript: Buffer.from(params.identityOutput.script, "hex"), value: 0n }
+  ];
+  if (offeringNative) {
+    tx.addOutput(nativePaymentScript2(params.sellerReceiveAddress), toSafeNumber(params.offered.amount));
+  } else {
+    const out = buildTokenChangeOutput(
+      parseAddress(params.sellerReceiveAddress, "sellerReceiveAddress"),
+      /* @__PURE__ */ new Map([[params.offered.currency, params.offered.amount]])
+    );
+    tx.addOutput(out.script, 0);
+  }
+  return fundFeeAndSignIdentityTaker({
+    tx,
+    priorInputs: takerInputs,
+    extraInputNative: commitmentNative,
+    takerUtxos: params.takerUtxos,
+    changeAddress: params.changeAddress,
+    wif: params.wif,
+    network,
+    label: "takeBuyIdentityOffer",
+    extraOutputBytes: 300
+  });
+}
+function buildSwapIdentityOffer(params, network) {
+  if (params.makerPrimaryAddresses.length === 0) {
+    throw new TransactionBuildError("buildSwapIdentityOffer: makerPrimaryAddresses must not be empty");
+  }
+  return buildBuyIdentityOffer(
+    {
+      wif: params.wif,
+      commitment: {
+        txid: params.offeredIdentityOutput.txid,
+        vout: params.offeredIdentityOutput.vout,
+        value: 0n,
+        // an identity primary output carries 0 native
+        script: params.offeredIdentityOutput.script
+      },
+      identityJson: params.wantedIdentityJson,
+      buyerPrimaryAddresses: params.makerPrimaryAddresses,
+      expiryHeight: params.expiryHeight
+    },
+    network
+  );
+}
+function completeSwapIdentityOffer(params, network) {
+  const verusNetwork = getNetwork(network === "testnet");
+  if (params.takerPrimaryAddresses.length === 0) {
+    throw new TransactionBuildError("completeSwapIdentityOffer: takerPrimaryAddresses must not be empty");
+  }
+  const tx = import_utxo_lib.Transaction.fromHex(params.offerTx, verusNetwork);
+  if (tx.ins.length !== 1 || tx.outs.length !== 1) {
+    throw new TransactionBuildError("completeSwapIdentityOffer: expected a maker offer partial (1 input, 1 output)");
+  }
+  tx.addOutput(buildTransferredIdentity(params.offeredIdentityJson, params.takerPrimaryAddresses), 0);
+  const idIdx = tx.addInput(
+    Buffer.from(params.wantedIdentityOutput.txid, "hex").reverse(),
+    params.wantedIdentityOutput.vout,
+    4294967295
+  );
+  const takerInputs = [
+    { index: idIdx, prevOutScript: Buffer.from(params.wantedIdentityOutput.script, "hex"), value: 0n }
+  ];
+  return fundFeeAndSignIdentityTaker({
+    tx,
+    priorInputs: takerInputs,
+    extraInputNative: 0n,
+    takerUtxos: params.takerUtxos,
+    changeAddress: params.changeAddress,
+    wif: params.wif,
+    network,
+    label: "takeSwapIdentityOffer",
+    extraOutputBytes: 500
+  });
+}
+
 // src/VerusSDK.ts
 var VerusSDK = class {
   constructor(config) {
@@ -34468,6 +34930,52 @@ var VerusSDK = class {
   verifyMessage(params) {
     return verifyMessage(params, this.network);
   }
+  // ─── Marketplace Offers (atomic swaps) ─────────────
+  /**
+   * Maker step 1 (currency offers only): fund the OFFERED asset into a commitment
+   * output. Broadcast the returned tx, then pass `commitment` to `buildOffer`.
+   */
+  buildOfferFunding(params) {
+    return buildOfferFunding(params, this.network);
+  }
+  /**
+   * Maker step 2 (currency offers): build the half-signed offer — spend the funded
+   * commitment with 0x83, committing to the single WANTED output paid to the maker.
+   */
+  buildOffer(params) {
+    return buildOffer(params, this.network);
+  }
+  /**
+   * Taker (currency offers): complete the maker's offer — pay the wanted asset,
+   * receive the offered asset, and sign the taker's side into an atomic swap.
+   */
+  completeOffer(params) {
+    return completeOffer(params, this.network);
+  }
+  /** Maker: offer a VerusID for a currency (spends the identity's on-chain output). */
+  buildSellIdentityOffer(params) {
+    return buildSellIdentityOffer(params, this.network);
+  }
+  /** Taker: complete a sell-identity offer — pay the currency, receive the identity. */
+  completeSellIdentityOffer(params) {
+    return completeSellIdentityOffer(params, this.network);
+  }
+  /** Maker: offer a currency for a VerusID (funds the currency into a commitment). */
+  buildBuyIdentityOffer(params) {
+    return buildBuyIdentityOffer(params, this.network);
+  }
+  /** Taker (identity owner): complete a buy-identity offer — give up the identity, take the currency. */
+  completeBuyIdentityOffer(params) {
+    return completeBuyIdentityOffer(params, this.network);
+  }
+  /** Maker: offer a VerusID for another VerusID (no currency moves). */
+  buildSwapIdentityOffer(params) {
+    return buildSwapIdentityOffer(params, this.network);
+  }
+  /** Taker (owns the wanted identity): complete an identity swap — funds only the miner fee. */
+  completeSwapIdentityOffer(params) {
+    return completeSwapIdentityOffer(params, this.network);
+  }
   // ─── Static Utilities ─────────────────────────────
   /** Derive R-address from WIF private key */
   static async deriveAddress(wif) {
@@ -34516,8 +35024,8 @@ function isIdentityName(input) {
 }
 
 // src/identity/public.ts
-var public_exports = {};
-__export(public_exports, {
+var public_exports2 = {};
+__export(public_exports2, {
   buildAndSignCommitment: () => buildAndSignCommitment,
   buildAndSignIdentityUpdate: () => buildAndSignIdentityUpdate,
   buildAndSignRegistration: () => buildAndSignRegistration,
@@ -34568,6 +35076,7 @@ __export(public_exports, {
   isVerusAddress,
   keys,
   message,
+  offers,
   parseSats,
   signing,
   toCoins,