@kaspacom/kcc20-tx-builder 0.8.0-fee.1 → 0.8.0-fee.3

package/src/engine.ts

@@ -77,6 +77,7 @@ import {
   ownerAuthorizationWitness,
 } from "./abi.js";
 import { KCC20_BUILDER_KEYS } from "./operations.js";
+import { buildKcc20InitialFeeAccount, planKcc20FeeAccountBinding } from "./escrow-account-setup.js";
 import { createKcc20SnapshotPsktBuilder } from "./snapshot-operation.js";
 import { splitKcc20MintSupply } from "./protocol.js";
 import { buildKcc20DeployIntentOutputs } from "./deploy-receipt.js";
@@ -553,6 +554,8 @@ export function createKcc20PsktBuilderEngine(
     "fee-ticket.create-from-utility-burn": buildFeeTicketCreatePskt,
     "fee-ticket.burn": buildFeeTicketBurnPskt,
     "fee-ticket.transfer": buildFeeTicketTransferPskt,
+    "kcc20fee.create-account": buildFeeAccountCreatePskt,
+    "kcc20fee.bind-account": buildFeeAccountBindPskt,
     "kcc20wrapper.deploy-market": buildWrapperMarketDeployPskt,
     "kcc20wrapper.wrap": buildWrapperWrapPskt,
     "kcc20wrapper.unwrap": buildWrapperUnwrapPskt,
@@ -606,6 +609,295 @@ export function createKcc20PsktBuilderEngine(
     return builder(input);
   }
 
+  async function buildFeeAccountCreatePskt(input) {
+    const request = input.request || {};
+    const params = request.params || {};
+    const tokenId = requireHex32(params.tokenId, "fee account token id");
+    const owner = requireHex32(request.owner?.kcc20Owner, "fee account owner");
+    const principalSompi = parseU64(params.principalSompi, "fee account principal");
+    const network = request.network || env.KASPA_NETWORK || "testnet-10";
+    const walletAddress = requireKaspaAddress(request.owner?.walletAddress);
+    const priorityFee = parseU64(
+      env.KCC20_FEE_ACCOUNT_PRIORITY_FEE_SOMPI || DEFAULT_PRIORITY_FEE.toString(),
+      "priorityFee",
+    );
+    const artifactKey = "KCC20FeeEscrowV1.placeholder.json";
+    const supplied = options.artifacts?.[artifactKey] ?? await options.artifactProvider?.(artifactKey);
+    const artifact = supplied?.artifact ?? supplied;
+    if (!artifact) throw new Error("missing pinned fee escrow artifact");
+    const initial = buildKcc20InitialFeeAccount({
+      artifact, tokenId, ownerSchnorrPublicKey: owner, principalSompi,
+    });
+    const kw = kaspaWasm;
+    const { Encoding, GenesisCovenantGroup, RpcClient, Transaction,
+      TransactionOutput, covenantId, payToAddressScript, payToScriptHashScript } = kw;
+    const rpc = new RpcClient({
+      url: env.KASPA_WRPC_URL || DEFAULT_WRPC_URL,
+      encoding: Encoding.Borsh,
+      networkId: network,
+    });
+    await rpc.connect();
+    try {
+      const walletUtxos = await getUtxosByAddresses(rpc, [walletAddress]);
+      const fundingEntry = selectFundingEntry(
+        walletUtxos.entries,
+        principalSompi + priorityFee + 10_000n,
+        [],
+        params.fundingOutpoint,
+      );
+      const fundingAmount = utxoAmountSompi(fundingEntry);
+      const change = fundingAmount - principalSompi - priorityFee;
+      if (change <= 10_000n) throw new Error("fee account creation funding change is too small");
+      const transaction = new Transaction({
+        version: 1,
+        lockTime: 0n,
+        inputs: [{ previousOutpoint: fundingEntry.outpoint, utxo: fundingEntry,
+          sequence: 0n, sigOpCount: 0, computeBudget: 30 }],
+        outputs: [
+          new TransactionOutput(principalSompi, payToScriptHashScript(initial.redeemScript)),
+          new TransactionOutput(change, payToAddressScript(walletAddress)),
+        ],
+        subnetworkId: SUBNETWORK_ID_NATIVE,
+        gas: 0n,
+        payload: "",
+      });
+      setVersionOneInputMassFields(transaction, 30);
+      transaction.populateGenesisCovenants([new GenesisCovenantGroup(0, [0])]);
+      transaction.finalize();
+      const accountId = transaction.outputs[0]?.covenant?.covenantId?.toString();
+      if (!accountId) throw new Error("fee account genesis covenant id is missing");
+      const expectedId = covenantId(fundingEntry.outpoint, [
+        { index: 0, output: transaction.outputs[0] },
+      ]).toString();
+      if (accountId !== expectedId) throw new Error("fee account genesis covenant id mismatch");
+      const feeResult = transactionWithPredictedSignedFeeChange(
+        kw, transaction, 1, network, "fee account creation", candidate => {
+          const predicted = cloneTransactionForMassPreflight(kw, candidate, "fee account creation");
+          predicted.inputs[0].signatureScript = encodeP2pkSignatureScript(bytesToHex(dummySignatureBytes()));
+          return predicted;
+        },
+      );
+      const nonContextualMass = calculateToccataV1NonContextualMass(
+        feeResult.predictedTransaction, "fee account creation",
+      ).transactionMass;
+      const storageMass = calculateToccataStorageMass(
+        feeResult.predictedTransaction, "fee account creation",
+      );
+      if (nonContextualMass > CONSOLIDATION_TARGET_TRANSACTION_MASS ||
+          storageMass > CONSOLIDATION_TARGET_TRANSACTION_MASS) {
+        throw kcc20PsktBuilderError(
+          "fee account creation exceeds the signed transaction mass target",
+          "TRANSACTION_MASS_EXCEEDED",
+          { nonContextualMass, storageMass, targetMass: CONSOLIDATION_TARGET_TRANSACTION_MASS },
+        );
+      }
+      const finalAccountId = covenantId(fundingEntry.outpoint, [
+        { index: 0, output: feeResult.transaction.outputs[0] },
+      ]).toString();
+      if (finalAccountId !== accountId) throw new Error("fee account genesis id changed after fee calculation");
+      const psktTransactionJson = feeResult.transaction.serializeToSafeJSON();
+      if (typeof psktTransactionJson !== "string") throw new Error("fee account creation PSKT serialization failed");
+      return {
+        schema: OUTPUT_SCHEMA,
+        psktTransactionJson,
+        signInputs: [{ index: 0, sighashType: 1 }],
+        scripts: [],
+        submitTransactionSupported: true,
+        metadata: {
+          builderKey: "kcc20fee.create-account",
+          operation: "create-fee-account",
+          action: "genesis",
+          contract: "KCC20FeeEscrowV1",
+          network, walletAddress, tokenId, owner, accountId,
+          accountPrincipalSompi: principalSompi.toString(),
+          // Attach the broadcast txid to this hint before binding. The first
+          // spend reveals the script; until then the indexer sees only P2SH.
+          accountGenesisHint: {
+            vout: 0,
+            address: kw.addressFromScriptPublicKey(
+              payToScriptHashScript(initial.redeemScript), network,
+            ).toString(),
+            covenantIdHex: accountId,
+            scriptHashHex: initial.scriptHash,
+            amountSompiExact: principalSompi.toString(),
+            state: { ...initial.state, roleName: "account" },
+          },
+        },
+      };
+    } finally {
+      await rpc.disconnect();
+    }
+  }
+
+  async function buildFeeAccountBindPskt(input) {
+    const request = input.request || {};
+    const params = request.params || {};
+    // A genesis output has no revealed script yet. The caller keeps the
+    // creation hint, adds its accepted txid, then we check the live UTXO.
+    const indexed = params.accountGenesisHint
+      ? { ...params.accountGenesisHint, status: "active", spentByTxidHex: null }
+      : params.activeAccountUtxo;
+    if (!indexed || !indexed.address) throw new Error("active unbound fee account UTXO and address are required");
+    const tokenId = requireHex32(params.tokenId, "fee account token id");
+    const accountId = requireHex32(params.accountId, "fee account id");
+    const marketId = requireHex32(params.marketId, "fee account market id");
+    const policyId = requireHex32(params.policyId, "fee account policy id");
+    const owner = requireHex32(request.owner?.kcc20Owner, "fee account owner");
+    if (String(indexed.state?.owner || "").toLowerCase() !== owner) {
+      throw new Error("fee account owner does not match connected wallet");
+    }
+    const network = request.network || env.KASPA_NETWORK || "testnet-10";
+    const walletAddress = requireKaspaAddress(request.owner?.walletAddress);
+    const accountAddress = requireKaspaAddress(indexed.address);
+    const priorityFee = parseU64(
+      env.KCC20_FEE_ACCOUNT_PRIORITY_FEE_SOMPI || DEFAULT_PRIORITY_FEE.toString(),
+      "priorityFee",
+    );
+    const computeBudget = parsePositiveNumber(
+      env.KCC20_FEE_ACCOUNT_COMPUTE_BUDGET || 500,
+      "computeBudget",
+    );
+    const artifactKey = "KCC20FeeEscrowV1.placeholder.json";
+    const supplied = options.artifacts?.[artifactKey] ?? await options.artifactProvider?.(artifactKey);
+    const artifact = supplied?.artifact ?? supplied;
+    if (!artifact) throw new Error("missing pinned fee escrow artifact");
+
+    const kw = kaspaWasm;
+    const { CovenantBinding, Encoding, Hash, RpcClient, Transaction,
+      TransactionOutput, payToAddressScript, payToScriptHashScript } = kw;
+    const rpc = new RpcClient({
+      url: env.KASPA_WRPC_URL || DEFAULT_WRPC_URL,
+      encoding: Encoding.Borsh,
+      networkId: network,
+    });
+    await rpc.connect();
+    try {
+      const [accountUtxos, walletUtxos] = await Promise.all([
+        getUtxosByAddresses(rpc, [accountAddress]),
+        getUtxosByAddresses(rpc, [walletAddress]),
+      ]);
+      const txid = requireHex32(indexed.txidHex, "fee account txid");
+      const vout = parseVout(indexed.vout, "fee account vout");
+      const accountEntry = findUtxoEntry(accountUtxos.entries, txid, vout);
+      if (!accountEntry) throw new Error("unbound fee account UTXO is spent or unavailable");
+      requireMatchingCovenantId(accountEntry, accountId, "unbound fee account");
+      const spk = accountEntry.scriptPublicKey ??
+        accountEntry.entry?.scriptPublicKey ?? accountEntry.utxoEntry?.scriptPublicKey;
+      const scriptBytes = spk?.script;
+      if (!spk || !scriptBytes) throw new Error("unbound fee account has no script public key");
+      const scriptHex = typeof scriptBytes === "string" ? scriptBytes : bytesToHex(scriptBytes);
+      const plan = planKcc20FeeAccountBinding({
+        artifact,
+        indexed,
+        live: {
+          outpoint: { transactionId: txid, index: vout },
+          amountSompi: utxoAmountSompi(accountEntry),
+          covenantIdHex: accountId,
+          scriptPublicKey: { version: Number(spk.version), scriptHex },
+        },
+        tokenId, accountId, marketId, policyId,
+      });
+      assertScriptAddress(kw, plan.currentRedeemScript, accountAddress, network, "unbound fee account address");
+      const fundingEntry = selectFundingEntry(
+        walletUtxos.entries,
+        priorityFee + 10_000n,
+        [],
+        params.fundingOutpoint,
+      );
+      const fundingAmount = utxoAmountSompi(fundingEntry);
+      if (fundingAmount <= priorityFee + 10_000n) throw new Error("fee account binding funding change is too small");
+      const unsignedTx = new Transaction({
+        version: 1,
+        lockTime: 0n,
+        inputs: [
+          { previousOutpoint: accountEntry.outpoint, utxo: accountEntry,
+            sequence: 0n, sigOpCount: 0, computeBudget },
+          { previousOutpoint: fundingEntry.outpoint, utxo: fundingEntry,
+            sequence: 0n, sigOpCount: 0, computeBudget: 30 },
+        ],
+        outputs: [
+          new TransactionOutput(
+            plan.successorAmountSompi,
+            payToScriptHashScript(plan.successorRedeemScript),
+            new CovenantBinding(0, new Hash(accountId)),
+          ),
+          new TransactionOutput(
+            fundingAmount - priorityFee,
+            payToAddressScript(walletAddress),
+          ),
+        ],
+        subnetworkId: SUBNETWORK_ID_NATIVE,
+        gas: 0n,
+        payload: "",
+      });
+      setVersionOneInputMassFields(unsignedTx, computeBudget);
+      unsignedTx.inputs[1].computeBudget = 30;
+      const scripts = [{
+        inputIndex: 0,
+        scriptHex: bytesToHex(plan.currentRedeemScript),
+        signType: 1,
+        signatureScript: {
+          mode: "ordered-args",
+          args: [
+            dataTemplateArg(hexToBytes(marketId)),
+            dataTemplateArg(hexToBytes(policyId)),
+            { type: "signature" },
+            i64TemplateArg(0),
+            dataTemplateArg(dispatchTagFor(artifact, "bindMarket")),
+          ],
+        },
+      }];
+      const feeResult = transactionWithPredictedSignedFeeChange(
+        kw, unsignedTx, 1, network, "fee account binding", candidate => {
+          const serialized = candidate.serializeToSafeJSON();
+          if (typeof serialized !== "string") throw new Error("fee account mass preflight serialization failed");
+          const predictedJson = transactionJsonWithScriptHints(kw, JSON.parse(serialized), scripts);
+          predictedJson.inputs[1].signatureScript = encodeP2pkSignatureScript(
+            bytesToHex(dummySignatureBytes()),
+          );
+          return typeof kw.Transaction.deserializeFromSafeJSON === "function"
+            ? kw.Transaction.deserializeFromSafeJSON(JSON.stringify(predictedJson))
+            : kw.Transaction.deserializeFromJSON(JSON.stringify(predictedJson));
+        },
+      );
+      const nonContextualMass = calculateToccataV1NonContextualMass(
+        feeResult.predictedTransaction, "fee account binding",
+      ).transactionMass;
+      const storageMass = calculateToccataStorageMass(
+        feeResult.predictedTransaction, "fee account binding",
+      );
+      if (nonContextualMass > CONSOLIDATION_TARGET_TRANSACTION_MASS ||
+          storageMass > CONSOLIDATION_TARGET_TRANSACTION_MASS) {
+        throw kcc20PsktBuilderError(
+          "fee account binding exceeds the signed transaction mass target",
+          "TRANSACTION_MASS_EXCEEDED",
+          { nonContextualMass, storageMass, targetMass: CONSOLIDATION_TARGET_TRANSACTION_MASS },
+        );
+      }
+      const transaction = feeResult.transaction;
+      const psktTransactionJson = transaction.serializeToSafeJSON();
+      if (typeof psktTransactionJson !== "string") throw new Error("fee account binding PSKT serialization failed");
+      return {
+        schema: OUTPUT_SCHEMA,
+        psktTransactionJson,
+        signInputs: [{ index: 1, sighashType: 1 }],
+        scripts,
+        submitTransactionSupported: true,
+        metadata: {
+          builderKey: "kcc20fee.bind-account",
+          operation: "bind-fee-account",
+          action: "bindMarket",
+          contract: "KCC20FeeEscrowV1",
+          network, walletAddress, tokenId, accountId, marketId, policyId,
+          accountInput: `${txid}:${vout}`,
+          accountPrincipalSompi: plan.successorAmountSompi.toString(),
+        },
+      };
+    } finally {
+      await rpc.disconnect();
+    }
+  }
+
   async function buildFeeTicketRootUpdatePskt(input) {
     const request = input.request || {};
     const params = request.params || {};

package/src/escrow-account-setup.ts

@@ -0,0 +1,124 @@
+import { normalizeSilverScriptArtifact, templateParts } from "./abi.js";
+import { KCC20_ESCROW_MAX_INT } from "./escrow-fee.js";
+import type { Kcc20FeeAccountState } from "./escrow-claim-plan.js";
+import {
+  buildKcc20FeeEscrowScript,
+  verifyKcc20UnboundFeeAccountForBinding,
+  type Kcc20IndexedFeeReceipt,
+  type Kcc20LiveFeeReceiptUtxo,
+} from "./escrow-receipt.js";
+
+const ZERO = "00".repeat(32);
+const SECP256K1_FIELD = (1n << 256n) - (1n << 32n) - 977n;
+
+function hex32(value: string, label: string): string {
+  if (typeof value !== "string" || !/^[0-9a-f]{64}$/i.test(value)) {
+    throw new Error(`${label} must be 32-byte hex`);
+  }
+  return value.toLowerCase();
+}
+
+function principal(value: bigint): bigint {
+  if (typeof value !== "bigint" || value <= 0n || value > KCC20_ESCROW_MAX_INT) {
+    throw new Error("fee account principal must be a positive contract-range bigint");
+  }
+  return value;
+}
+
+function modPow(base: bigint, exponent: bigint): bigint {
+  let result = 1n;
+  let factor = base % SECP256K1_FIELD;
+  for (let remaining = exponent; remaining > 0n; remaining >>= 1n) {
+    if (remaining & 1n) result = (result * factor) % SECP256K1_FIELD;
+    factor = (factor * factor) % SECP256K1_FIELD;
+  }
+  return result;
+}
+
+/** BIP340 keys encode an x-coordinate that must lift to a secp256k1 point. */
+function requireSchnorrXOnlyPublicKey(value: string): string {
+  const key = hex32(value, "owner Schnorr public key");
+  const x = BigInt(`0x${key}`);
+  if (x >= SECP256K1_FIELD) throw new Error("owner Schnorr public key is not a curve point");
+  const square = (x * x % SECP256K1_FIELD * x + 7n) % SECP256K1_FIELD;
+  const y = modPow(square, (SECP256K1_FIELD + 1n) / 4n);
+  if (y * y % SECP256K1_FIELD !== square) {
+    throw new Error("owner Schnorr public key is not a curve point");
+  }
+  return key;
+}
+
+/**
+ * Construct the initial account output. Its covenant lineage is assigned by
+ * the transaction; the market can bind that lineage only after it is known.
+ * This function does not select funding, sign, or estimate transaction mass.
+ */
+export function buildKcc20InitialFeeAccount(input: {
+  artifact: unknown;
+  tokenId: string;
+  ownerSchnorrPublicKey: string;
+  principalSompi: bigint;
+}) {
+  const token = hex32(input.tokenId, "token");
+  const owner = requireSchnorrXOnlyPublicKey(input.ownerSchnorrPublicKey);
+  if (token === ZERO || owner === ZERO) throw new Error("fee account token and owner must be nonzero");
+  const amountSompi = principal(input.principalSompi);
+  const template = templateParts(normalizeSilverScriptArtifact(input.artifact));
+  const state: Kcc20FeeAccountState = {
+    role: "1", token, market: ZERO, policy: ZERO,
+    protocol_account: ZERO, creator_account: ZERO,
+    protocol_amount: "0", creator_amount: "0", owner,
+    owner_scheme: 0, guard_template: ZERO, guard_prefix: "0", guard_suffix: "0",
+    action_hash: ZERO,
+    self_template: toHex(template.hash),
+    self_prefix: String(template.prefixLength), self_suffix: String(template.suffixLength),
+  };
+  return { state, amountSompi, ...buildKcc20FeeEscrowScript(input.artifact, state as unknown as Record<string, unknown>) };
+}
+
+function toHex(bytes: Uint8Array): string {
+  return Array.from(bytes, byte => byte.toString(16).padStart(2, "0")).join("");
+}
+
+/**
+ * Verify the current unbound account output and plan the exact continuation.
+ * The owner signs bindMarket once; later claims use the account's authority.
+ */
+export function planKcc20FeeAccountBinding(input: {
+  artifact: unknown;
+  indexed: Kcc20IndexedFeeReceipt;
+  live: Kcc20LiveFeeReceiptUtxo;
+  tokenId: string;
+  accountId: string;
+  marketId: string;
+  policyId: string;
+}) {
+  const market = hex32(input.marketId, "market");
+  const policy = hex32(input.policyId, "policy");
+  if (market === ZERO || policy === ZERO) throw new Error("fee account binding requires a market and policy");
+  const verified = verifyKcc20UnboundFeeAccountForBinding({
+    artifact: input.artifact,
+    indexed: input.indexed,
+    live: input.live,
+    expected: { tokenId: input.tokenId, accountId: input.accountId },
+  });
+  const successorState: Kcc20FeeAccountState = {
+    ...verified.account.state,
+    market, policy,
+  };
+  const successor = buildKcc20FeeEscrowScript(
+    input.artifact,
+    successorState as unknown as Record<string, unknown>,
+  );
+  return {
+    entrypoint: "bindMarket" as const,
+    account: verified.account,
+    currentRedeemScript: verified.redeemScript,
+    successorState,
+    successorRedeemScript: successor.redeemScript,
+    successorScriptPublicKey: successor.scriptPublicKey,
+    successorAmountSompi: verified.account.principalSompi,
+    requiresOwnerSchnorrSignature: true as const,
+    requiresSeparateNetworkFunding: true as const,
+  };
+}

package/src/escrow-claim-plan.ts

@@ -0,0 +1,130 @@
+import { calculateKcc20FeeClaim, KCC20_ESCROW_MAX_INT, type Kcc20FeeReceiptAmounts } from "./escrow-fee.js";
+import { kcc20FeeClaimCommitment } from "./escrow-policy.js";
+
+const ZERO = "00".repeat(32);
+const HEX_32 = /^[0-9a-f]{64}$/i;
+
+export interface Kcc20FeeAccountState {
+  role: string;
+  token: string;
+  market: string;
+  policy: string;
+  protocol_account: string;
+  creator_account: string;
+  protocol_amount: string;
+  creator_amount: string;
+  owner: string;
+  owner_scheme: number;
+  guard_template: string;
+  guard_prefix: string;
+  guard_suffix: string;
+  action_hash: string;
+  self_template: string;
+  self_prefix: string;
+  self_suffix: string;
+}
+
+export interface Kcc20FeeClaimAccount {
+  outpoint: { transactionId: string; index: number };
+  covenantId: string;
+  principalSompi: bigint;
+  state: Kcc20FeeAccountState;
+}
+
+function hex32(value: string, label: string): string {
+  if (typeof value !== "string" || !HEX_32.test(value)) throw new Error(`${label} must be 32-byte hex`);
+  return value.toLowerCase();
+}
+
+function natural(value: string, label: string): bigint {
+  if (typeof value !== "string" || !/^(0|[1-9]\d*)$/.test(value)) throw new Error(`${label} must be canonical decimal`);
+  const result = BigInt(value);
+  if (result > KCC20_ESCROW_MAX_INT) throw new Error(`${label} exceeds the contract range`);
+  return result;
+}
+
+/**
+ * Derive the exact claim amounts and covenant successor states. Inputs must
+ * already be authenticated against current node UTXOs. This plan does not
+ * authorize account ownership, sign, estimate mass or select network funding.
+ */
+export function planKcc20FeeClaimTransition(input: {
+  receipts: readonly Kcc20FeeReceiptAmounts[];
+  party: "protocol" | "creator";
+  account: Kcc20FeeClaimAccount;
+  /** Supplied by a successful pinned receipt verification, not by an indexer hint alone. */
+  escrowTemplate: { hash: string; prefixLength: number; suffixLength: number };
+  /** Serialized ScriptPublicKey including its two-byte little-endian version. */
+  payoutScriptPublicKey: Uint8Array;
+}) {
+  const amounts = calculateKcc20FeeClaim(input.receipts, input.party);
+  const first = input.receipts[0]!;
+  const account = input.account;
+  const state = account.state;
+  const targetAccount = input.party === "protocol" ? first.protocolAccountId : first.creatorAccountId;
+  if (hex32(targetAccount, "target account") === ZERO ||
+      hex32(account.covenantId, "account covenant") !== hex32(targetAccount, "target account")) {
+    throw new Error("claim uses the wrong fee account lineage");
+  }
+  if (!Number.isInteger(account.outpoint.index) || account.outpoint.index < 0 || account.outpoint.index > 0xffffffff ||
+      hex32(account.outpoint.transactionId, "account txid") === ZERO ||
+      typeof account.principalSompi !== "bigint" || account.principalSompi <= 0n ||
+      account.principalSompi > KCC20_ESCROW_MAX_INT) {
+    throw new Error("invalid fee account outpoint or principal");
+  }
+  if (state.role !== "1" || hex32(state.token, "account token") !== hex32(first.tokenId, "receipt token") ||
+      hex32(state.market, "account market") !== hex32(first.marketId, "receipt market") ||
+      hex32(state.policy, "account policy") !== hex32(first.policyId, "receipt policy") ||
+      [state.protocol_account, state.creator_account, state.owner].some(value => !HEX_32.test(value)) ||
+      state.protocol_account.toLowerCase() !== ZERO || state.creator_account.toLowerCase() !== ZERO ||
+      state.owner.toLowerCase() === ZERO || state.protocol_amount !== "0" || state.creator_amount !== "0") {
+    throw new Error("invalid fee account state");
+  }
+  if (!Number.isInteger(state.owner_scheme) || state.owner_scheme < 0 || state.owner_scheme > 4 ||
+      !HEX_32.test(state.guard_template) || !HEX_32.test(state.action_hash) || !HEX_32.test(state.self_template)) {
+    throw new Error("unsupported fee account authority state");
+  }
+  const guardPrefix = natural(state.guard_prefix, "guard prefix");
+  const guardSuffix = natural(state.guard_suffix, "guard suffix");
+  const selfPrefix = natural(state.self_prefix, "self prefix");
+  const selfSuffix = natural(state.self_suffix, "self suffix");
+  if (!Number.isSafeInteger(input.escrowTemplate.prefixLength) ||
+      !Number.isSafeInteger(input.escrowTemplate.suffixLength) ||
+      input.escrowTemplate.prefixLength <= 0 || input.escrowTemplate.suffixLength <= 0 ||
+      state.self_template.toLowerCase() !== hex32(input.escrowTemplate.hash, "escrow template") ||
+      selfPrefix !== BigInt(input.escrowTemplate.prefixLength) ||
+      selfSuffix !== BigInt(input.escrowTemplate.suffixLength) ||
+      (state.owner_scheme === 3 && (state.guard_template.toLowerCase() === ZERO || guardPrefix !== 0n || guardSuffix !== 0n)) ||
+      (state.owner_scheme === 4 && (state.guard_template.toLowerCase() === ZERO || guardPrefix === 0n || guardSuffix === 0n)) ||
+      (state.owner_scheme <= 2 && (state.guard_template.toLowerCase() !== ZERO || guardPrefix !== 0n || guardSuffix !== 0n))) {
+    throw new Error("invalid fee account guard state");
+  }
+  const commitment = kcc20FeeClaimCommitment({
+    receipts: input.receipts,
+    party: input.party,
+    accountOutpoint: account.outpoint,
+    payoutScriptPublicKey: input.payoutScriptPublicKey,
+  });
+  const successorAccountState: Kcc20FeeAccountState = { ...state, action_hash: commitment };
+  const remainderReceiptState = amounts.remainderSompi > 0n ? {
+    role: "0", token: first.tokenId, market: first.marketId, policy: first.policyId,
+    protocol_account: first.protocolAccountId, creator_account: first.creatorAccountId,
+    protocol_amount: amounts.remainingProtocolSompi.toString(),
+    creator_amount: amounts.remainingCreatorSompi.toString(),
+    owner: ZERO, owner_scheme: 0, guard_template: ZERO,
+    guard_prefix: "0", guard_suffix: "0", action_hash: ZERO,
+    self_template: input.escrowTemplate.hash.toLowerCase(),
+    self_prefix: String(input.escrowTemplate.prefixLength),
+    self_suffix: String(input.escrowTemplate.suffixLength),
+  } : null;
+  return {
+    party: input.party,
+    claimSompi: amounts.claimSompi,
+    accountPrincipalSompi: account.principalSompi,
+    remainderSompi: amounts.remainderSompi,
+    commitment,
+    successorAccountState,
+    remainderReceiptState,
+    requiresSeparateNetworkFunding: true as const,
+  };
+}