@kronsdk/kron-sdk 0.4.0 → 0.6.0

package/dist/index.js

@@ -163,12 +163,24 @@ var ZERO_COVID = "00".repeat(32);
 // src/native/spend.ts
 var spend_exports = {};
 __export(spend_exports, {
+  COVENANT_COMPUTE: () => COVENANT_COMPUTE,
+  COVENANT_DUST: () => COVENANT_DUST,
+  FUNDING_COMPUTE: () => FUNDING_COMPUTE,
+  TOKEN_COMPUTE: () => TOKEN_COMPUTE,
+  TX_VERSION: () => TX_VERSION,
   assembleNativeTx: () => assembleNativeTx,
+  estimateNativeFee: () => estimateNativeFee,
   signFundingInputs: () => signFundingInputs,
   signPsktWithKey: () => signPsktWithKey,
   toPsktJson: () => toPsktJson
 });
+var TX_VERSION = 1;
+var FUNDING_COMPUTE = 10;
+var TOKEN_COMPUTE = 500;
+var COVENANT_COMPUTE = 2e3;
+var COVENANT_DUST = 50000000n;
 var SUBNET_ZERO = "0000000000000000000000000000000000000000";
+var budgetForRole = (role) => role === "curve" || role === "pool" ? COVENANT_COMPUTE : TOKEN_COMPUTE;
 function assembleNativeTx(k, opts) {
   const { spend, fundingEntries, changeAddress, networkFee } = opts;
   const kk = k;
@@ -178,6 +190,7 @@ function assembleNativeTx(k, opts) {
       signatureScript: ci.signatureScript,
       sequence: 0n,
       sigOpCount: 0,
+      computeBudget: ci.computeBudget ?? budgetForRole(ci.role),
       utxo: {
         outpoint: { transactionId: ci.transactionId, index: ci.index },
         amount: ci.value,
@@ -188,7 +201,7 @@ function assembleNativeTx(k, opts) {
     })
   );
   const fundingInputs = fundingEntries.map(
-    (e) => new kk.TransactionInput({ previousOutpoint: e.outpoint, signatureScript: "", sequence: 0n, sigOpCount: 1, utxo: e })
+    (e) => new kk.TransactionInput({ previousOutpoint: e.outpoint, signatureScript: "", sequence: 0n, sigOpCount: 0, computeBudget: FUNDING_COMPUTE, utxo: e })
   );
   const covInValue = spend.inputs.reduce((s, ci) => s + ci.value, 0n);
   const fundingTotal = fundingEntries.reduce((s, e) => s + BigInt(e.amount), 0n);
@@ -196,10 +209,12 @@ function assembleNativeTx(k, opts) {
   const covenantOut = spend.outputs.reduce((s, o) => s + o.value, 0n);
   const change = totalIn - covenantOut - networkFee;
   if (change < 0n) throw new Error(`insufficient funding: need ${covenantOut + networkFee} sompi, have ${totalIn}`);
-  const outputs = spend.outputs.map((o) => new kk.TransactionOutput(o.value, o.scriptPublicKey));
+  const outputs = spend.outputs.map(
+    (o) => o.binding ? new kk.TransactionOutput(o.value, o.scriptPublicKey, new kk.CovenantBinding(o.binding.authorizingInput, new kk.Hash(o.binding.covid))) : new kk.TransactionOutput(o.value, o.scriptPublicKey)
+  );
   outputs.push(new kk.TransactionOutput(change, kk.payToAddressScript(changeAddress)));
   const transaction = new kk.Transaction({
-    version: 0,
+    version: TX_VERSION,
     inputs: [...covInputs, ...fundingInputs],
     outputs,
     lockTime: 0n,
@@ -215,6 +230,27 @@ function assembleNativeTx(k, opts) {
     change
   };
 }
+function estimateNativeFee(k, networkId, asm, feeRateSompiPerGram) {
+  const kk = k;
+  const tx = asm.transaction;
+  const ins = tx.inputs;
+  const saved = asm.fundingInputIndexes.map((i) => ins[i].signatureScript);
+  for (const i of asm.fundingInputIndexes) ins[i].signatureScript = "00".repeat(66);
+  tx.inputs = ins;
+  let byteMass = 2000n;
+  try {
+    byteMass = BigInt(kk.calculateTransactionMass(networkId, tx));
+  } catch {
+  }
+  const ins2 = tx.inputs;
+  asm.fundingInputIndexes.forEach((i, j) => ins2[i].signatureScript = saved[j]);
+  tx.inputs = ins2;
+  let computeGrams = 0n;
+  for (const inp of tx.inputs) computeGrams += BigInt(inp.computeBudget || 0) * 100n;
+  const rate = BigInt(Math.max(Math.ceil(feeRateSompiPerGram), 1));
+  const fee = (byteMass + computeGrams) * rate * 3n / 2n;
+  return fee > 10000n ? fee : 10000n;
+}
 function signFundingInputs(k, tx, privKey, fundingInputIndexes) {
   const inputs = tx.inputs;
   for (const idx of fundingInputIndexes) {
@@ -247,7 +283,9 @@ var kcc20Tx_exports = {};
 __export(kcc20Tx_exports, {
   IDENTIFIER: () => IDENTIFIER,
   addressPresenceOwned: () => addressPresenceOwned,
+  buildKcc20Send: () => buildKcc20Send,
   covenantIdOwned: () => covenantIdOwned,
+  decodeKcc20Redeem: () => decodeKcc20Redeem,
   kcc20Address: () => kcc20Address,
   kcc20Spk: () => kcc20Spk,
   kcc20SpkForState: () => kcc20SpkForState,
@@ -259,6 +297,7 @@ __export(kcc20Tx_exports, {
   transferSigScript: () => transferSigScript
 });
 var IDENTIFIER = { PUBKEY: 0, SCRIPT_HASH: 1, COVENANT_ID: 2, ADDRESS: 3 };
+var STATE_LEN = 46;
 function materializeKcc20Script(tpl, state) {
   const s = tpl.stateStart;
   const t = tpl.script;
@@ -278,6 +317,25 @@ function materializeKcc20Script(tpl, state) {
   out[s + 45] = state.isMinter ? 1 : 0;
   return out;
 }
+function decodeKcc20Redeem(redeem, opts = {}) {
+  const hits = [];
+  for (let s2 = 0; s2 + STATE_LEN <= redeem.length; s2++) {
+    if (redeem[s2] === 32 && redeem[s2 + 33] === 1 && redeem[s2 + 34] <= 3 && redeem[s2 + 35] === 8 && redeem[s2 + 44] === 1 && redeem[s2 + 45] <= 1) hits.push(s2);
+  }
+  if (hits.length !== 1) throw new Error(`could not locate the kcc20 state region in the redeem script (${hits.length} candidate offsets) \u2014 is this a kcc20 token UTXO?`);
+  const s = hits[0];
+  let amount = 0n;
+  for (let i = 7; i >= 0; i--) amount = amount << 8n | BigInt(redeem[s + 36 + i]);
+  return {
+    template: { script: redeem.slice(), stateStart: s, maxIns: opts.maxIns ?? 4, maxOuts: opts.maxOuts ?? 4 },
+    state: {
+      ownerIdentifier: redeem.slice(s + 1, s + 33),
+      identifierType: redeem[s + 34],
+      amount,
+      isMinter: redeem[s + 45] === 1
+    }
+  };
+}
 var kcc20Spk = (k, redeem) => k.payToScriptHashScript(redeem);
 var kcc20SpkForState = (k, tpl, state) => kcc20Spk(k, materializeKcc20Script(tpl, state));
 function kcc20Address(k, tpl, state, network) {
@@ -327,6 +385,30 @@ function transferSigScript(k, redeem, newStates, witnesses, sigs = []) {
   b.redeem(redeem);
   return b.drain();
 }
+function buildKcc20Send(k, tpl, senderTokens, recipientPubkey32, sendAmount, presenceWitnessIdx, tokenCovid, opts = {}) {
+  if (senderTokens.length < 1) throw new Error("send requires at least one token UTXO");
+  if (!tokenCovid) throw new Error("send requires the token covenant id (indexer token info `covenantId`) for the output bindings");
+  const total = senderTokens.reduce((s, t) => s + t.state.amount, 0n);
+  const change = total - sendAmount;
+  if (sendAmount < 1n || change < 0n) throw new Error(`send requires 1 <= sendAmount <= ${total} (the selected UTXOs' total)`);
+  const dust = opts.tokenDust ?? 50000000n;
+  const owner = senderTokens[0].state.ownerIdentifier;
+  const recipientOut = addressPresenceOwned(recipientPubkey32, sendAmount);
+  const newStates = change >= 1n ? [recipientOut, addressPresenceOwned(owner, change)] : [recipientOut];
+  const witnesses = senderTokens.map(() => presenceWitnessIdx);
+  const inputs = senderTokens.map((t) => {
+    const r = materializeKcc20Script(tpl, t.state);
+    return { transactionId: t.transactionId, index: t.index, value: t.value, scriptPublicKey: kcc20Spk(k, r), signatureScript: transferSigScript(k, r, newStates, witnesses), redeem: r, role: "token" };
+  });
+  const binding = { covid: tokenCovid, authorizingInput: 0 };
+  const outputs = newStates.map((st, i) => ({
+    value: dust,
+    scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tpl, st)),
+    role: i === 0 ? "send" : "change",
+    binding
+  }));
+  return { kind: "transfer", inputs, outputs, economics: { sendAmount, change }, covids: { tokenCovid } };
+}
 
 // src/native/curveCpTx.ts
 var curveCpTx_exports = {};
@@ -496,6 +578,9 @@ function buildAddLiquidity(k, tpl, tokenTpl, utxo, lpInventory, poolCovid, lpDep
   if (lpDepositToken.state.amount !== q.dToken) throw new Error("LP deposit token UTXO must equal dToken exactly (split first)");
   const dust = opts.tokenDust ?? 1000n;
   const { kasReserve, tokenReserve, tokenCovid, lpCovid } = utxo.state;
+  const poolCovidHex = hexOf(poolCovid);
+  const tokenCovidHex = hexOf(tokenCovid);
+  const lpCovidHex = hexOf(lpCovid);
   const poolTokenOut = covenantIdOwned(poolCovid, q.newToken, false);
   const poolLpOut = covenantIdOwned(poolCovid, lpInventory.amount - q.dShares, false);
   const lpSharesOut = addressPresenceOwned(lpPubkey, q.dShares);
@@ -515,17 +600,20 @@ function buildAddLiquidity(k, tpl, tokenTpl, utxo, lpInventory, poolCovid, lpDep
     { transactionId: lpInventory.transactionId, index: lpInventory.index, value: lpInventory.value, scriptPublicKey: kcc20Spk(k, poolLpInvRedeem), signatureScript: transferSigScript(k, poolLpInvRedeem, lStates, lWitnesses), redeem: poolLpInvRedeem, role: "poolLpInventory" }
   ];
   const outputs = [
-    { value: q.newKas * SCALE, scriptPublicKey: poolCpSpk(k, newRedeem), role: "pool" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolTokenOut)), role: "poolToken" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolLpOut)), role: "poolLpInventory" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, lpSharesOut)), role: "lpShares" }
+    { value: q.newKas * SCALE, scriptPublicKey: poolCpSpk(k, newRedeem), role: "pool", binding: { covid: poolCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolTokenOut)), role: "poolToken", binding: { covid: tokenCovidHex, authorizingInput: 2 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolLpOut)), role: "poolLpInventory", binding: { covid: lpCovidHex, authorizingInput: 3 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, lpSharesOut)), role: "lpShares", binding: { covid: lpCovidHex, authorizingInput: 3 } }
   ];
-  return { kind: "addLiquidity", inputs, outputs, economics: { dKas: q.dKas, dToken: q.dToken, dShares: q.dShares, newShares: q.newShares }, covids: { poolCovid: hexOf(poolCovid), tokenCovid: hexOf(tokenCovid) } };
+  return { kind: "addLiquidity", inputs, outputs, economics: { dKas: q.dKas, dToken: q.dToken, dShares: q.dShares, newShares: q.newShares }, covids: { poolCovid: poolCovidHex, tokenCovid: tokenCovidHex } };
 }
 function buildRemoveLiquidity(k, tpl, tokenTpl, utxo, lpShares, poolCovid, lpPubkey, q, presenceWitnessIdx, opts = {}) {
   if (lpShares.state.amount !== q.dShares) throw new Error("LP shares UTXO must equal dShares exactly (split first)");
   const dust = opts.tokenDust ?? 1000n;
   const { kasReserve, tokenReserve, tokenCovid, lpCovid } = utxo.state;
+  const poolCovidHex = hexOf(poolCovid);
+  const tokenCovidHex = hexOf(tokenCovid);
+  const lpCovidHex = hexOf(lpCovid);
   const poolTokenOut = covenantIdOwned(poolCovid, q.newToken, false);
   const lpTokenOut = addressPresenceOwned(lpPubkey, q.dToken);
   const poolLpOut = covenantIdOwned(poolCovid, q.dShares, false);
@@ -543,12 +631,12 @@ function buildRemoveLiquidity(k, tpl, tokenTpl, utxo, lpShares, poolCovid, lpPub
     { transactionId: lpShares.transactionId, index: lpShares.index, value: lpShares.value, scriptPublicKey: kcc20Spk(k, lpSharesRedeem), signatureScript: transferSigScript(k, lpSharesRedeem, lStates, lWitnesses), redeem: lpSharesRedeem, role: "lpShares" }
   ];
   const outputs = [
-    { value: q.newKas * SCALE, scriptPublicKey: poolCpSpk(k, newRedeem), role: "pool" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolTokenOut)), role: "poolToken" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, lpTokenOut)), role: "lpToken" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolLpOut)), role: "poolLpInventory" }
+    { value: q.newKas * SCALE, scriptPublicKey: poolCpSpk(k, newRedeem), role: "pool", binding: { covid: poolCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolTokenOut)), role: "poolToken", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, lpTokenOut)), role: "lpToken", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolLpOut)), role: "poolLpInventory", binding: { covid: lpCovidHex, authorizingInput: 2 } }
   ];
-  return { kind: "removeLiquidity", inputs, outputs, economics: { dShares: q.dShares, dKas: q.dKas, dToken: q.dToken, newShares: q.newShares }, covids: { poolCovid: hexOf(poolCovid), tokenCovid: hexOf(tokenCovid) } };
+  return { kind: "removeLiquidity", inputs, outputs, economics: { dShares: q.dShares, dKas: q.dKas, dToken: q.dToken, newShares: q.newShares }, covids: { poolCovid: poolCovidHex, tokenCovid: tokenCovidHex } };
 }
 function buildBindLp(k, tpl, tokenTpl, utxo, poolCovid, lockedShares, opts = {}) {
   if (utxo.state.lpCovid.length !== 32 || !utxo.state.lpCovid.every((b2) => b2 === 0)) throw new Error("pool lpCovid is already bound \u2014 bindLp is one-time");
@@ -576,12 +664,13 @@ function buildBindLp(k, tpl, tokenTpl, utxo, poolCovid, lockedShares, opts = {})
   const inputs = [
     { transactionId: utxo.transactionId, index: utxo.index, value: poolValue, scriptPublicKey: poolCpSpk(k, curRedeem), signatureScript: bindSig, redeem: curRedeem, role: "pool" }
   ];
+  const poolCovidHex = hexOf(poolCovid);
   const outputs = [
-    { value: poolValue, scriptPublicKey: poolCpSpk(k, boundRedeem), role: "pool" },
-    { value: dust, scriptPublicKey: floorSpk, role: "lpFloor" },
-    { value: dust, scriptPublicKey: invSpk, role: "lpInventory" }
+    { value: poolValue, scriptPublicKey: poolCpSpk(k, boundRedeem), role: "pool", binding: { covid: poolCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: floorSpk, role: "lpFloor", binding: { covid: lpCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: invSpk, role: "lpInventory", binding: { covid: lpCovidHex, authorizingInput: 0 } }
   ];
-  return { kind: "bindLp", inputs, outputs, economics: { lockedShares, inventoryAmount }, covids: { poolCovid: hexOf(poolCovid), tokenCovid: hexOf(tokenCovid) }, lpCovidHex, lpInventoryAmount: inventoryAmount };
+  return { kind: "bindLp", inputs, outputs, economics: { lockedShares, inventoryAmount }, covids: { poolCovid: poolCovidHex, tokenCovid: hexOf(tokenCovid) }, lpCovidHex, lpInventoryAmount: inventoryAmount };
 }
 
 // src/native/curveCpTx.ts
@@ -639,6 +728,8 @@ function buildCpBuy(k, tpl, tokenTpl, utxo, inventory, curveCovid, buyerPubkey,
   if (tokenOut <= 0n || tokenOut >= inventory.amount) throw new Error("invalid tokenOut");
   if (inventory.amount !== utxo.state.tokenReserve) throw new Error("inventory.amount must equal the curve's committed tokenReserve");
   const dust = opts.tokenDust ?? 1000n;
+  const curveCovidHex = hexOf2(curveCovid);
+  const tokenCovidHex = hexOf2(utxo.state.tokenCovid);
   const newKas = utxo.realKas + kasIn;
   if (newKas > MAX_KAS) throw new Error("buy exceeds the curve max raise (9,000,000 TKAS)");
   const newToken = inventory.amount - tokenOut;
@@ -664,13 +755,13 @@ function buildCpBuy(k, tpl, tokenTpl, utxo, inventory, curveCovid, buyerPubkey,
     })
   ];
   const outputs = [
-    { value: newKas, scriptPublicKey: cpSpk(k, newCurveRedeem), role: "curve" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, invOutRedeem), role: "inventory" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, buyerRedeem), role: "recipient" },
+    { value: newKas, scriptPublicKey: cpSpk(k, newCurveRedeem), role: "curve", binding: { covid: curveCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, invOutRedeem), role: "inventory", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, buyerRedeem), role: "recipient", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
     { value: padFee3(creatorFee), scriptPublicKey: p2pkSpk(k, tpl.params.creatorFeeOwner), role: "creatorFee" },
     { value: padFee3(platformFee), scriptPublicKey: p2pkSpk(k, tpl.params.platformFeeOwner), role: "platformFee" }
   ];
-  return { kind: "buy", inputs, outputs, economics: { kasIn, tokenOut, creatorFee, platformFee, newRealKas: newKas, newTokenReserve: newToken, merged: mergeSum }, covids: { tokenCovid: hexOf2(utxo.state.tokenCovid) } };
+  return { kind: "buy", inputs, outputs, economics: { kasIn, tokenOut, creatorFee, platformFee, newRealKas: newKas, newTokenReserve: newToken, merged: mergeSum }, covids: { tokenCovid: tokenCovidHex } };
 }
 function buildCpSell(k, tpl, tokenTpl, utxo, sellerTokens, inventory, curveCovid, traderPubkey, tokenIn, kasOut, presenceWitnessIdx, opts = {}) {
   if (utxo.state.graduated) throw new Error("curve has graduated \u2014 sells are locked");
@@ -679,6 +770,8 @@ function buildCpSell(k, tpl, tokenTpl, utxo, sellerTokens, inventory, curveCovid
   if (kasOut <= 0n || kasOut % SCALE2 !== 0n || kasOut > utxo.realKas) throw new Error("invalid kasOut");
   if (inventory.amount !== utxo.state.tokenReserve) throw new Error("inventory.amount must equal the curve's committed tokenReserve");
   const dust = opts.tokenDust ?? 1000n;
+  const curveCovidHex = hexOf2(curveCovid);
+  const tokenCovidHex = hexOf2(utxo.state.tokenCovid);
   const sellerIn = sellerTokens.reduce((s, t) => s + t.state.amount, 0n);
   const change = sellerIn - tokenIn;
   if (change < 0n) throw new Error("seller inputs are less than the sell amount");
@@ -703,13 +796,13 @@ function buildCpSell(k, tpl, tokenTpl, utxo, sellerTokens, inventory, curveCovid
     })
   ];
   const outputs = [
-    { value: utxo.realKas - kasOut, scriptPublicKey: cpSpk(k, newCurveRedeem), role: "curve" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, invOutRedeem), role: "inventory" },
+    { value: utxo.realKas - kasOut, scriptPublicKey: cpSpk(k, newCurveRedeem), role: "curve", binding: { covid: curveCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, invOutRedeem), role: "inventory", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
     { value: padFee3(creatorFee), scriptPublicKey: p2pkSpk(k, tpl.params.creatorFeeOwner), role: "creatorFee" },
     { value: padFee3(platformFee), scriptPublicKey: p2pkSpk(k, tpl.params.platformFeeOwner), role: "platformFee" }
   ];
-  if (hasChange) outputs.push({ value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, traderChangeOut)), role: "seller" });
-  return { kind: "sell", inputs, outputs, economics: { tokenIn, kasOut, change, creatorFee, platformFee, newRealKas: utxo.realKas - kasOut, newTokenReserve: newToken }, covids: { tokenCovid: hexOf2(utxo.state.tokenCovid) } };
+  if (hasChange) outputs.push({ value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, traderChangeOut)), role: "seller", binding: { covid: tokenCovidHex, authorizingInput: 1 } });
+  return { kind: "sell", inputs, outputs, economics: { tokenIn, kasOut, change, creatorFee, platformFee, newRealKas: utxo.realKas - kasOut, newTokenReserve: newToken }, covids: { tokenCovid: tokenCovidHex } };
 }
 function buildCpGraduate(k, tpl, tokenTpl, poolTemplate, utxo, inventory, curveCovid, poolLockedShares, opts = {}) {
   if (utxo.state.graduated) throw new Error("already graduated");
@@ -740,10 +833,12 @@ function buildCpGraduate(k, tpl, tokenTpl, poolTemplate, utxo, inventory, curveC
     { transactionId: utxo.transactionId, index: utxo.index, value: utxo.realKas, scriptPublicKey: cpSpk(k, curRedeem), signatureScript: graduateSigV2(k, curRedeem, poolState, poolTokens), redeem: curRedeem, role: "curve" },
     { transactionId: inventory.transactionId, index: inventory.index, value: inventory.value, scriptPublicKey: kcc20Spk(k, invRedeem), signatureScript: transferSigScript(k, invRedeem, [poolTokens], [0]), redeem: invRedeem, role: "inventory" }
   ];
+  const curveCovidHex = hexOf2(curveCovid);
+  const tokenCovidHex = hexOf2(A);
   const outputs = [
-    { value: lockedValue, scriptPublicKey: cpSpk(k, lockedRedeem), role: "curve" },
-    { value: poolKas, scriptPublicKey: poolSpkV, role: "pool" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, poolTokenRedeem), role: "poolToken" },
+    { value: lockedValue, scriptPublicKey: cpSpk(k, lockedRedeem), role: "curve", binding: { covid: curveCovidHex, authorizingInput: 0 } },
+    { value: poolKas, scriptPublicKey: poolSpkV, role: "pool", binding: { covid: poolCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, poolTokenRedeem), role: "poolToken", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
     { value: padFee3(gradFee), scriptPublicKey: p2pkSpk(k, tpl.params.platformFeeOwner), role: "gradFee" }
   ];
   return { kind: "graduate", inputs, outputs, economics: { poolKas, gradFee, leftover, poolLockedShares }, covids: { tokenCovid: hexOf2(A), poolCovid: poolCovidHex } };
@@ -756,14 +851,15 @@ function buildSplitToken(k, tokenTpl, sellerToken, sellAmount, presenceWitnessId
   const out1 = addressPresenceOwned(owner, sellAmount);
   const out2 = addressPresenceOwned(owner, change);
   const redeem = materializeKcc20Script(tokenTpl, sellerToken.state);
+  const binding = opts.tokenCovid ? { covid: opts.tokenCovid, authorizingInput: 0 } : void 0;
   const inputs = [
     { transactionId: sellerToken.transactionId, index: sellerToken.index, value: sellerToken.value, scriptPublicKey: kcc20Spk(k, redeem), signatureScript: transferSigScript(k, redeem, [out1, out2], [presenceWitnessIdx]), redeem, role: "sellerToken" }
   ];
   const outputs = [
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, out1)), role: "split" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, out2)), role: "change" }
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, out1)), role: "split", binding },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, out2)), role: "change", binding }
   ];
-  return { kind: "sell", inputs, outputs, economics: { sellAmount, change }, covids: { tokenCovid: hexOf2(owner) } };
+  return { kind: "sell", inputs, outputs, economics: { sellAmount, change }, covids: opts.tokenCovid ? { tokenCovid: opts.tokenCovid } : {} };
 }
 function buildConsolidate(k, tokenTpl, tokens, presenceWitnessIdx, opts = {}) {
   if (tokens.length < 2) throw new Error("consolidate needs at least 2 UTXOs");
@@ -777,10 +873,11 @@ function buildConsolidate(k, tokenTpl, tokens, presenceWitnessIdx, opts = {}) {
     const r = materializeKcc20Script(tokenTpl, t.state);
     return { transactionId: t.transactionId, index: t.index, value: t.value, scriptPublicKey: kcc20Spk(k, r), signatureScript: transferSigScript(k, r, newStates, witnesses), redeem: r, role: "token" };
   });
+  const binding = opts.tokenCovid ? { covid: opts.tokenCovid, authorizingInput: 0 } : void 0;
   const outputs = [
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, merged)), role: "merged" }
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, merged)), role: "merged", binding }
   ];
-  return { kind: "sell", inputs, outputs, economics: { total }, covids: { tokenCovid: hexOf2(owner) } };
+  return { kind: "sell", inputs, outputs, economics: { total }, covids: opts.tokenCovid ? { tokenCovid: opts.tokenCovid } : {} };
 }
 var hexOf2 = (u8) => Array.from(u8, (b) => b.toString(16).padStart(2, "0")).join("");
 
@@ -825,6 +922,8 @@ function v3SwapSellSig(k, redeem, kasOutUnits, poolTokenOut, traderChangeOut) {
 function buildPoolV3SwapKasForToken(k, tpl, tokenTpl, params, utxo, poolCovid, traderPubkey, q, mergeTokens = [], presenceWitnessIdx = 0, opts = {}) {
   const dust = opts.tokenDust ?? 1000n;
   const { kasReserve, tokenReserve, tokenCovid, totalShares, lpCovid } = utxo.state;
+  const poolCovidHex = hexOf3(poolCovid);
+  const tokenCovidHex = hexOf3(tokenCovid);
   const mergeSum = mergeTokens.reduce((s, t) => s + t.state.amount, 0n);
   const poolTokenOut = covenantIdOwned(poolCovid, q.newToken, false);
   const traderTokenOut = addressPresenceOwned(traderPubkey, q.tokenOut + mergeSum);
@@ -842,18 +941,20 @@ function buildPoolV3SwapKasForToken(k, tpl, tokenTpl, params, utxo, poolCovid, t
     })
   ];
   const outputs = [
-    { value: q.newKas * SCALE, scriptPublicKey: poolCpV3Spk(k, newRedeem), role: "pool" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolTokenOut)), role: "poolToken" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, traderTokenOut)), role: "trader" },
+    { value: q.newKas * SCALE, scriptPublicKey: poolCpV3Spk(k, newRedeem), role: "pool", binding: { covid: poolCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolTokenOut)), role: "poolToken", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, traderTokenOut)), role: "trader", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
     { value: q.creatorOut, scriptPublicKey: p2pkSpk2(k, params.creatorFeeOwner), role: "creatorFee" },
     { value: q.platformOut, scriptPublicKey: p2pkSpk2(k, params.platformFeeOwner), role: "platformFee" }
   ];
-  return { kind: "swapKasForToken", inputs, outputs, economics: { kasIn: q.kasIn, tokenOut: q.tokenOut }, covids: { poolCovid: hexOf3(poolCovid), tokenCovid: hexOf3(tokenCovid) } };
+  return { kind: "swapKasForToken", inputs, outputs, economics: { kasIn: q.kasIn, tokenOut: q.tokenOut }, covids: { poolCovid: poolCovidHex, tokenCovid: tokenCovidHex } };
 }
 function buildPoolV3SwapTokenForKas(k, tpl, tokenTpl, params, utxo, poolCovid, traderPubkey, traderTokens, q, presenceWitnessIdx, opts = {}) {
   if (traderTokens.length < 1) throw new Error("need at least one trader token");
   const dust = opts.tokenDust ?? 1000n;
   const { kasReserve, tokenReserve, tokenCovid, totalShares, lpCovid } = utxo.state;
+  const poolCovidHex = hexOf3(poolCovid);
+  const tokenCovidHex = hexOf3(tokenCovid);
   const traderIn = traderTokens.reduce((s, t) => s + t.state.amount, 0n);
   const change = traderIn - q.tokenIn;
   if (change < 0n) throw new Error("trader inputs are less than the sell amount");
@@ -874,13 +975,13 @@ function buildPoolV3SwapTokenForKas(k, tpl, tokenTpl, params, utxo, poolCovid, t
     })
   ];
   const outputs = [
-    { value: q.newKas * SCALE, scriptPublicKey: poolCpV3Spk(k, newRedeem), role: "pool" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolTokenOut)), role: "poolToken" },
+    { value: q.newKas * SCALE, scriptPublicKey: poolCpV3Spk(k, newRedeem), role: "pool", binding: { covid: poolCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, poolTokenOut)), role: "poolToken", binding: { covid: tokenCovidHex, authorizingInput: 1 } },
     { value: q.creatorOut, scriptPublicKey: p2pkSpk2(k, params.creatorFeeOwner), role: "creatorFee" },
     { value: q.platformOut, scriptPublicKey: p2pkSpk2(k, params.platformFeeOwner), role: "platformFee" }
   ];
-  if (hasChange) outputs.push({ value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, traderChangeOut)), role: "trader" });
-  return { kind: "swapTokenForKas", inputs, outputs, economics: { kasOut: q.kasOut, tokenIn: q.tokenIn }, covids: { poolCovid: hexOf3(poolCovid), tokenCovid: hexOf3(tokenCovid) } };
+  if (hasChange) outputs.push({ value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, traderChangeOut)), role: "trader", binding: { covid: tokenCovidHex, authorizingInput: 1 } });
+  return { kind: "swapTokenForKas", inputs, outputs, economics: { kasOut: q.kasOut, tokenIn: q.tokenIn }, covids: { poolCovid: poolCovidHex, tokenCovid: tokenCovidHex } };
 }
 
 // src/native/vestingTx.ts
@@ -895,6 +996,7 @@ __export(vestingTx_exports, {
   vestingSpkForState: () => vestingSpkForState
 });
 var VEST_SELECTOR = { claim: 0, claimFinal: 1 };
+var hexOf4 = (u8) => Array.from(u8, (b) => b.toString(16).padStart(2, "0")).join("");
 function vestedAmount(total, startScore, durationScore, daaScore) {
   if (daaScore <= startScore) return 0n;
   const elapsed = BigInt(daaScore - startScore);
@@ -920,6 +1022,8 @@ function buildVestingClaim(k, vestTpl, tokenTpl, vestingUtxo, lockedToken, vesti
   const remaining = total - claimed;
   if (release <= 0n || release >= remaining) throw new Error("partial claim must be > 0 and < remaining (use claimFinal to drain)");
   const dust = opts.tokenDust ?? 1000n;
+  const vestingCovidHex = hexOf4(vestingCovid);
+  const tokenBinding = opts.tokenCovid ? { covid: opts.tokenCovid, authorizingInput: 1 } : void 0;
   const newClaimed = claimed + release, newRemaining = remaining - release;
   const curRedeem = materializeVestingScript(vestTpl, claimed);
   const newRedeem = materializeVestingScript(vestTpl, newClaimed);
@@ -936,20 +1040,22 @@ function buildVestingClaim(k, vestTpl, tokenTpl, vestingUtxo, lockedToken, vesti
     { transactionId: lockedToken.transactionId, index: lockedToken.index, value: lockedToken.value, scriptPublicKey: kcc20Spk(k, lockedRedeem), signatureScript: transferSigScript(k, lockedRedeem, [relockState, recipientState], [0]), redeem: lockedRedeem, role: "lockedToken" }
   ];
   const outputs = [
-    { value: vestingUtxo.value, scriptPublicKey: vestingSpk(k, newRedeem), role: "vesting" },
+    { value: vestingUtxo.value, scriptPublicKey: vestingSpk(k, newRedeem), role: "vesting", binding: { covid: vestingCovidHex, authorizingInput: 0 } },
     // V continuation (claimed bumped)
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, relockState)), role: "relock" },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, relockState)), role: "relock", binding: tokenBinding },
     // re-locked (A, V-owned)
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, recipientState)), role: "recipient" }
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, recipientState)), role: "recipient", binding: tokenBinding }
     // to creator (A, presence)
   ];
-  return { kind: "claim", inputs, outputs, economics: { release, newClaimed } };
+  return { kind: "claim", inputs, outputs, economics: { release, newClaimed }, covids: opts.tokenCovid ? { tokenCovid: opts.tokenCovid } : {} };
 }
 function buildVestingClaimFinal(k, vestTpl, tokenTpl, vestingUtxo, lockedToken, vestingCovid, creatorPubkey, claimed, opts = {}) {
   const total = BigInt(vestTpl.params.total);
   if (claimed < 0n || claimed >= total) throw new Error("nothing left to claim");
   const remaining = total - claimed;
   const dust = opts.tokenDust ?? 1000n;
+  const vestingCovidHex = hexOf4(vestingCovid);
+  const tokenBinding = opts.tokenCovid ? { covid: opts.tokenCovid, authorizingInput: 1 } : void 0;
   const curRedeem = materializeVestingScript(vestTpl, claimed);
   const newRedeem = materializeVestingScript(vestTpl, total);
   const lockedState = covenantIdOwned(vestingCovid, remaining, false);
@@ -963,10 +1069,10 @@ function buildVestingClaimFinal(k, vestTpl, tokenTpl, vestingUtxo, lockedToken,
     { transactionId: lockedToken.transactionId, index: lockedToken.index, value: lockedToken.value, scriptPublicKey: kcc20Spk(k, lockedRedeem), signatureScript: transferSigScript(k, lockedRedeem, [recipientState], [0]), redeem: lockedRedeem, role: "lockedToken" }
   ];
   const outputs = [
-    { value: vestingUtxo.value, scriptPublicKey: vestingSpk(k, newRedeem), role: "vesting" },
-    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, recipientState)), role: "recipient" }
+    { value: vestingUtxo.value, scriptPublicKey: vestingSpk(k, newRedeem), role: "vesting", binding: { covid: vestingCovidHex, authorizingInput: 0 } },
+    { value: dust, scriptPublicKey: kcc20Spk(k, materializeKcc20Script(tokenTpl, recipientState)), role: "recipient", binding: tokenBinding }
   ];
-  return { kind: "claimFinal", inputs, outputs, economics: { release: remaining } };
+  return { kind: "claimFinal", inputs, outputs, economics: { release: remaining }, covids: opts.tokenCovid ? { tokenCovid: opts.tokenCovid } : {} };
 }
 
 // src/wallet/index.ts