@fundtokens/builders 0.1.0-rc5

package/PublicFundTransactionBuilder.js

@@ -0,0 +1,336 @@
+import {
+    Contract,
+    TransactionBuilder,
+} from 'cashscript';
+import {
+    swapEndianness,
+    hash256,
+    hexToBin,
+    binToHex,
+    cashAddressToLockingBytecode,
+} from '@bitauth/libauth';
+import {
+    getBestFee,
+    getFundBin,
+    getFundHex,
+    getRandomInt,
+    withDust,
+} from './utils.js';
+import FundTokenTransactionBuilder from './FundTokenTransactionBuilder.js';
+
+import feeJson from './art/fee.json' with { type: 'json' };
+import startupJson from './art/startup.json' with { type: 'json' };
+import mintInflowJson from './art/mint_inflow.json' with { type: 'json' };
+import mintOutflowJson from './art/mint_outflow.json' with { type: 'json' };
+import managerJson from './art/manager.json' with { type: 'json' };
+import fundJson from './art/fund.json' with { type: 'json' };
+import assetJson from './art/asset.json' with { type: 'json' };
+import publicJson from './art/public.json' with { type: 'json' };
+import simpleVaultJson from './art/simple_vault.json' with { type: 'json' };
+import authHeadVaultJson from './art/authhead_vault.json' with { type: 'json' };
+import publicFundVaultJson from './art/public_vault.json' with { type: 'json' };
+
+export default class PublicFundTransactionBuilder extends TransactionBuilder {
+    #system = {
+        inflow: '', // 32 byte, token id
+        outflow: '', // 32 byte, token id
+        publicFund: '', // 32 byte, token id
+        authorization: '', // 32 byte, token id
+        fees: {
+            create: {
+                nft: '', // 32 byte, tx id/token id
+                value: -1n, // bigint
+            },
+            execute: {
+                nft: '', // 32 byte, tx id/token id
+                value: -1n, // bigint
+            }
+        },
+    };
+    #swapped = {
+        inflow: '',
+        outflow: '',
+        publicFund: '',
+        authorization: '',
+        fees: {
+            create: {
+                nft: '',
+            },
+            execute: {
+                nft: '',
+            },
+        },
+    };
+    #contracts = {
+        startupContract: null,
+        mintInflowContract: null,
+        mintOutflowContract: null,
+        createFundFeeContract: null,
+        executeFundFeeContract: null,
+        publicFundContract: null,
+        feeVaultContract: null,
+        authHeadVaultContract: null,
+        publicFundVaultContract: null,
+    };
+    #logger = null;
+
+    constructor({
+        provider,
+        system,
+        logger,
+    }) {
+        if (!system) {
+            throw new Error('No system configuration provided, unable to continue');
+        }
+        super({ provider });
+        this.#system = system;
+        this.#swapped = {
+            inflow: swapEndianness(system.inflow),
+            outflow: swapEndianness(system.outflow),
+            publicFund: swapEndianness(system.publicFund),
+            authorization: swapEndianness(system.authorization),
+            fees: {
+                create: {
+                    nft: swapEndianness(system.fees.create.nft),
+                },
+                execute: {
+                    nft: swapEndianness(system.fees.execute.nft),
+                }
+            }
+        };
+        this.#logger = logger ?? this.#logger;
+        this.#buildContracts();
+    }
+
+    // build and get the contracts
+    #buildContracts() {
+        const feeVaultContract = new Contract(simpleVaultJson, [this.#swapped.authorization], { provider: this.provider });
+        const feeVaultLockingBytecode = binToHex(cashAddressToLockingBytecode(feeVaultContract.tokenAddress).bytecode);
+
+        const createFundFeeContract = new Contract(feeJson, [this.#swapped.authorization, feeVaultLockingBytecode, this.#swapped.fees.create.nft, BigInt(this.#system.fees.create.value)], { provider: this.provider });
+        const executeFundFeeContract = new Contract(feeJson, [this.#swapped.authorization, feeVaultLockingBytecode, this.#swapped.fees.execute.nft, BigInt(this.#system.fees.execute.value)], { provider: this.provider });
+
+        const startupContract = new Contract(startupJson, [
+            binToHex(hash256(hexToBin(createFundFeeContract.bytecode))),
+            this.#swapped.inflow,
+            this.#swapped.outflow,
+        ], { provider: this.provider });
+        const startupContractHash = binToHex(hash256(hexToBin(startupContract.bytecode)))
+
+        const mintInflowContract = new Contract(mintInflowJson, [
+            startupContractHash,
+            this.#swapped.inflow,
+            this.#swapped.outflow,
+            binToHex(hash256(hexToBin(executeFundFeeContract.bytecode))),
+            hexToBin(managerJson.debug.bytecode),
+            hexToBin(fundJson.debug.bytecode),
+            hexToBin(assetJson.debug.bytecode),
+        ], { provider: this.provider });
+
+        const mintOutflowContract = new Contract(mintOutflowJson, [
+            startupContractHash,
+            this.#swapped.inflow,
+            this.#swapped.outflow,
+            binToHex(hash256(hexToBin(executeFundFeeContract.bytecode))),
+            hexToBin(managerJson.debug.bytecode),
+            hexToBin(fundJson.debug.bytecode),
+            hexToBin(assetJson.debug.bytecode),
+        ], { provider: this.provider });
+
+        const authHeadVaultContract = new Contract(authHeadVaultJson, [this.#swapped.authorization], { provider: this.provider });
+        const authHeadVaultLockingBytecode = binToHex(cashAddressToLockingBytecode(authHeadVaultContract.tokenAddress).bytecode);
+
+        const publicFundVaultContract = new Contract(publicFundVaultJson, [this.#swapped.publicFund, this.#swapped.authorization], { provider: this.provider });
+        const publicFundVaultLockingBytecode = binToHex(cashAddressToLockingBytecode(publicFundVaultContract.tokenAddress).bytecode);
+
+        const publicFundContract = new Contract(publicJson, [
+            authHeadVaultLockingBytecode,
+            publicFundVaultLockingBytecode,
+            this.#swapped.publicFund,
+            startupContractHash,
+            fundJson.debug.bytecode,
+            this.#swapped.inflow,
+            this.#swapped.outflow,
+        ], { provider: this.provider });
+
+
+        this.#contracts = {
+            startupContract,
+            mintInflowContract,
+            mintOutflowContract,
+            createFundFeeContract,
+            executeFundFeeContract,
+            publicFundContract,
+            feeVaultContract,
+            authHeadVaultContract,
+            publicFundVaultContract,
+        };
+    }
+
+    getContracts() {
+        return this.#contracts;
+    }
+
+    async addBroadcast({
+        fund,
+        payBy,
+    }) {
+        const {
+            feeVaultContract,
+            createFundFeeContract,
+            startupContract,
+            mintInflowContract,
+            mintOutflowContract,
+            publicFundContract,
+            authHeadVaultContract,
+            publicFundVaultContract,
+        } = this.#contracts;
+
+        if(this.inputs.length === 0) {
+            throw new Error('User genesis input is expected to be added prior to calling this function');
+        }
+
+        if(this.outputs.length > 0) {
+            throw new Error('No outputs should be added to the transaction');
+        }
+
+        const genesisUtxo = this.inputs[0];
+
+        if(genesisUtxo.vout !== 0 || genesisUtxo.token) {
+            throw new Error('First input must be a genesis input (vout is 0) with no tokens');
+        }
+
+
+        const bestFee = await getBestFee({ feeVaultContract, feeContract: createFundFeeContract, payBy, fee: this.#system.fees.create });
+
+        const broadcastUtxos = await startupContract.getUtxos();
+        const mintInflowUtxos = await mintInflowContract.getUtxos();
+        const mintOutflowUtxos = await mintOutflowContract.getUtxos();
+        const publicUtxos = await publicFundContract.getUtxos();
+        const inflowUtxos = mintInflowUtxos.filter(u => u.token?.category === this.#system.inflow);
+        const outflowUtxos = mintOutflowUtxos.filter(u => u.token?.category === this.#system.outflow);
+        const publicFundUtxos = publicUtxos.filter(u => u.token?.category === this.#system.publicFund)
+
+
+        const broadcastUtxo = broadcastUtxos[getRandomInt(broadcastUtxos.length)];
+        const inflowUtxo = inflowUtxos[getRandomInt(inflowUtxos.length)];
+        const outflowUtxo = outflowUtxos[getRandomInt(outflowUtxos.length)];
+        const publicFundUtxo = publicFundUtxos[getRandomInt(publicFundUtxos.length)];
+
+        var { managerContract, fundContract } = new FundTokenTransactionBuilder({ provider: this.provider, system: { ...this.#system, fee: this.#system.fees.execute }, fund }).getContracts();
+
+        const fundTokenAmount = 9223372036854775807n;
+
+        this.addInputs([
+            {
+                ...broadcastUtxo,
+                unlocker: startupContract.unlock.start(getFundBin(fund)),
+            }, 
+            {
+                ...inflowUtxo,
+                unlocker: mintInflowContract.unlock.mint(),
+            }, 
+            {
+                ...outflowUtxo,
+                unlocker: mintOutflowContract.unlock.mint(),
+            },
+            {
+                ...bestFee.utxo,
+                unlocker: createFundFeeContract.unlock.pay(),
+            },
+            {
+                ...publicFundUtxo,
+                unlocker: publicFundContract.unlock.broadcast(getFundBin(fund))
+            }
+        ])
+        .addOutputs([
+            withDust({
+                to: authHeadVaultContract.tokenAddress,
+            }),
+            {
+                to: startupContract.tokenAddress,
+                amount: broadcastUtxo.satoshis,
+                token: broadcastUtxo.token,
+            },
+            {
+                to: mintInflowContract.tokenAddress,
+                amount: inflowUtxo.satoshis,
+                token: inflowUtxo.token,
+            },
+            {
+                to: mintOutflowContract.tokenAddress,
+                amount: outflowUtxo.satoshis,
+                token: outflowUtxo.token,
+            }, 
+            ...bestFee.outputs,
+            withDust({
+                to: managerContract.tokenAddress,
+                token: {
+                    ...inflowUtxo.token,
+                    nft: {
+                        capability: 'none',
+                        commitment: swapEndianness(genesisUtxo.txid) + binToHex(hash256(getFundBin(fund))),
+                    }
+                }
+            }),
+            withDust({
+                to: managerContract.tokenAddress,
+                token: {
+                    ...outflowUtxo.token,
+                    nft: {
+                        capability: 'none',
+                        commitment: swapEndianness(genesisUtxo.txid) + binToHex(hash256(getFundBin(fund))),
+                    }
+                }
+            }),
+            withDust({
+                to: fundContract.tokenAddress,
+                token: {
+                    category: genesisUtxo.txid,
+                    amount: fundTokenAmount,
+                }
+            }),
+            withDust({
+                to: publicFundContract.tokenAddress,
+                token: {
+                    category: this.#system.publicFund,
+                    amount: 0n,
+                    nft: {
+                        capability: 'minting',
+                        commitment: '',
+                    }
+                }
+            }),
+        ]);
+
+
+        const maxSize = 128 * 2;
+
+        const fundHex = getFundHex(fund);
+        const fundHexParts = [];
+        
+        let curr = 0;
+        let next = maxSize;
+
+
+        while(curr < fundHex.length) {
+            fundHexParts.push(fundHex.slice(curr, next));
+            curr = next;
+            next += maxSize
+        }
+
+        fundHexParts.forEach(part => {
+            this.addOutput(withDust({
+                to:  publicFundVaultContract.tokenAddress,
+                token: {
+                    category: this.#system.publicFund,
+                    amount: 0n,
+                    nft: {
+                        capability: 'none',
+                        commitment: part
+                    }
+                }
+            }))
+        });
+    }
+}

package/art/asset.json

@@ -0,0 +1,52 @@
+{
+  "contractName": "AssetManager",
+  "constructorInputs": [
+    {
+      "name": "outflowToken",
+      "type": "bytes32"
+    },
+    {
+      "name": "fundHash",
+      "type": "bytes32"
+    },
+    {
+      "name": "assetCategory",
+      "type": "bytes32"
+    }
+  ],
+  "abi": [
+    {
+      "name": "release",
+      "inputs": []
+    }
+  ],
+  "bytecode": "OP_0 OP_0 OP_BEGIN OP_DUP OP_UTXOTOKENCATEGORY OP_3 OP_PICK OP_EQUAL OP_IF OP_DUP OP_UTXOTOKENCOMMITMENT 40 OP_SPLIT OP_DROP 20 OP_SPLIT OP_NIP OP_4 OP_PICK OP_EQUAL OP_IF OP_1 OP_ROT OP_DROP OP_SWAP OP_ENDIF OP_ENDIF OP_DUP OP_1ADD OP_NIP OP_DUP OP_TXINPUTCOUNT OP_LESSTHAN OP_2 OP_PICK OP_NOT OP_BOOLAND OP_NOT OP_UNTIL OP_SWAP OP_VERIFY 0000000000000000000000000000000000000000000000000000000000000000 OP_4 OP_PICK OP_EQUAL OP_IF OP_INPUTINDEX OP_UTXOTOKENCATEGORY OP_0 OP_EQUALVERIFY OP_ELSE OP_INPUTINDEX OP_UTXOTOKENCATEGORY OP_4 OP_PICK OP_EQUALVERIFY OP_ENDIF OP_2DROP OP_2DROP OP_1",
+  "source": "pragma cashscript ~0.13.0;\r\n\r\n/**\r\n * AssetManager: Holds individual fund assets\r\n * \r\n * Each asset in a fund has a dedicated AssetManager contract instance.\r\n * Releases assets only when outflow token is present with matching fund hash.\r\n * \r\n * This contract gates asset access during redemption (outflow) transactions.\r\n * Amount verification is performed by the TransactionManager contract.\r\n * \r\n * Parameters:\r\n *   outflowToken: Token category that authorizes redemption\r\n *   fundHash: Hash of fund parameters (prevents spending wrong fund's assets)\r\n *   assetCategory: The specific asset category this contract holds\r\n *                  (0x00...00 = Bitcoin satoshis, else = token category)\r\n */\r\ncontract AssetManager(bytes32 outflowToken, bytes32 fundHash, bytes32 assetCategory) \r\n{\r\n    /**\r\n     * release(): Releases held assets when outflow is authorized\r\n     * \r\n     * Ensures:\r\n     * - Outflow token with matching fund hash is present (correct redemption)\r\n     * - Asset type is verified (Bitcoin satoshis or tokens)\r\n     * \r\n     * Note: AssetManager relies on TransactionManager for amount validation.\r\n     * This contract only gates access; amounts are verified elsewhere.\r\n     */\r\n    function release() {\r\n        // Check for outflow token with matching fund hash\r\n        bool outflowTokenSeen = false;\r\n        int inputIndex = 0;\r\n        do {\r\n            if(tx.inputs[inputIndex].tokenCategory == outflowToken) {\r\n                // Extract fund hash from NFT commitment [0:32] = category, [32:64] = hash\r\n                if(tx.inputs[inputIndex].nftCommitment.slice(32, 64) == fundHash) {\r\n                    // Correct fund's outflow token found - authorized to release\r\n                    outflowTokenSeen = true;\r\n                }\r\n            }\r\n            inputIndex = inputIndex + 1;\r\n        } while(inputIndex < tx.inputs.length && !outflowTokenSeen);\r\n        // Must have found the outflow token for this specific fund\r\n        require(outflowTokenSeen);\r\n        \r\n        // Verify asset type matches\r\n        bytes32 satoshiAsset = 0x0000000000000000000000000000000000000000000000000000000000000000;\r\n        if(assetCategory == satoshiAsset) {\r\n            // For Bitcoin: input should have no token (satoshis only)\r\n            require(tx.inputs[this.activeInputIndex].tokenCategory == 0x);\r\n        } else {\r\n            // For tokens: input must have the correct asset category\r\n            require(tx.inputs[this.activeInputIndex].tokenCategory == assetCategory);\r\n        }\r\n    }\r\n}",
+  "debug": {
+    "bytecode": "00006576ce5379876376cf01407f7501207f7754798763517b757c6868768b7776c39f5279919a91667c6920000000000000000000000000000000000000000000000000000000000000000054798763c0ce008867c0ce547988686d6d51",
+    "sourceMap": "32:32:32:37;33:25:33:26;34:8:43:68;35:25:35:35;:15::50:1;:54::66:0;;:15:::1;:68:41:13:0;37:29:37:39;:19::54:1;:65::67:0;:19::68:1;;:61::63:0;:19::68:1;;:72::80:0;;:19:::1;:82:40:17:0;39:39:39:43;:20::44:1;;;37:82:40:17;35:68:41:13;42:25:42:35:0;:::39:1;:12::40;43:16:43:26:0;:29::45;:16:::1;:50::66:0;;:49:::1;:16;34:8::68;;45:16:45:32:0;:8::34:1;48:31:48:97:0;49:11:49:24;;:::40:1;:42:52:9:0;51:30:51:51;:20::66:1;:70::72:0;:12::74:1;52:15:55:9:0;54:30:54:51;:20::66:1;:70::83:0;;:12::85:1;52:15:55:9;30:4:56:5;;",
+    "logs": [],
+    "requires": [
+      {
+        "ip": 43,
+        "line": 45
+      },
+      {
+        "ip": 52,
+        "line": 51
+      },
+      {
+        "ip": 58,
+        "line": 54
+      }
+    ]
+  },
+  "compiler": {
+    "name": "cashc",
+    "version": "0.13.0-next.6",
+    "options": {
+      "enforceFunctionParameterTypes": true
+    }
+  },
+  "updatedAt": "2026-04-21T19:21:04.268Z"
+}

package/art/authhead_vault.json

@@ -0,0 +1,47 @@
+{
+  "contractName": "AuthHeadVault",
+  "constructorInputs": [
+    {
+      "name": "authToken",
+      "type": "bytes32"
+    }
+  ],
+  "abi": [
+    {
+      "name": "release",
+      "inputs": []
+    }
+  ],
+  "bytecode": "OP_INPUTINDEX OP_0 OP_NUMEQUALVERIFY OP_0 OP_OUTPUTTOKENCATEGORY OP_0 OP_EQUALVERIFY OP_0 OP_0 OP_BEGIN OP_DUP OP_UTXOTOKENCATEGORY OP_3 OP_PICK OP_EQUAL OP_IF OP_1 OP_ROT OP_DROP OP_SWAP OP_ENDIF OP_DUP OP_1ADD OP_NIP OP_DUP OP_TXINPUTCOUNT OP_LESSTHAN OP_2 OP_PICK OP_NOT OP_BOOLAND OP_NOT OP_UNTIL OP_DROP OP_NIP",
+  "source": "pragma cashscript ~0.13.0;\r\n\r\n/**\r\n * AuthHeadVault: Authorization vault with strict positioning requirements\r\n * \r\n * Extends SimpleVault with additional constraints to maintain authhead w/ no token:\r\n * - Must be the first input (index 0)\r\n * - First output must not contain any tokens\r\n * \r\n * Used specifically for authorizing fund's BCMR update operations.\r\n * \r\n * Parameters:\r\n *   authToken: Token category that authorizes fund creation\r\n */\r\ncontract AuthHeadVault(bytes32 authToken)\r\n{\r\n    /**\r\n     * release(): Authorizes authhead operations with strict transaction structure\r\n     * \r\n     * Ensures:\r\n     * - This vault is the first input (positioning control)\r\n     * - First output has no tokens (clean state to maintain authhead integrity)\r\n     * - Authorization token is present in inputs\r\n     */\r\n    function release() {\r\n        // This vault MUST be the first input\r\n        require(this.activeInputIndex == 0, \"expected to be the first input\");\r\n        \r\n        // First output must have no tokens (ensures clean state to maintain authhead integrity)\r\n        require(tx.outputs[0].tokenCategory == 0x, \"no token allowed on authhead\");\r\n\r\n        // Check for authorization token in ANY input\r\n        bool authorized = false;\r\n        int inputIndex = 0;\r\n        do {\r\n            if(tx.inputs[inputIndex].tokenCategory == authToken) {\r\n                authorized = true;\r\n            }\r\n            inputIndex = inputIndex + 1;\r\n        } while(inputIndex < tx.inputs.length && !authorized);\r\n        require(authorized, \"unauthorized user\");\r\n    }\r\n}",
+  "debug": {
+    "bytecode": "c0009d00d1008800006576ce53798763517b757c68768b7776c39f5279919a91667577",
+    "sourceMap": "27:16:27:37;:41::42;:8::78:1;30:27:30:28:0;:16::43:1;:47::49:0;:8::83:1;33:26:33:31:0;34:25:34:26;35:8:40:62;36:25:36:35;:15::50:1;:54::63:0;;:15:::1;:65:38:13:0;37:29:37:33;:16::34:1;;;36:65:38:13;39:25:39:35:0;:::39:1;:12::40;40:16:40:26:0;:29::45;:16:::1;:50::60:0;;:49:::1;:16;35:8::62;;25:4:42:5;",
+    "logs": [],
+    "requires": [
+      {
+        "ip": 3,
+        "line": 27,
+        "message": "expected to be the first input"
+      },
+      {
+        "ip": 7,
+        "line": 30,
+        "message": "no token allowed on authhead"
+      },
+      {
+        "ip": 34,
+        "line": 41,
+        "message": "unauthorized user"
+      }
+    ]
+  },
+  "compiler": {
+    "name": "cashc",
+    "version": "0.13.0-next.6",
+    "options": {
+      "enforceFunctionParameterTypes": true
+    }
+  },
+  "updatedAt": "2026-04-21T19:21:06.353Z"
+}

package/art/fee.json

@@ -0,0 +1,97 @@
+{
+  "contractName": "FeeManager",
+  "constructorInputs": [
+    {
+      "name": "authToken",
+      "type": "bytes32"
+    },
+    {
+      "name": "destination",
+      "type": "bytes"
+    },
+    {
+      "name": "feeToken",
+      "type": "bytes32"
+    },
+    {
+      "name": "defaultValue",
+      "type": "int"
+    }
+  ],
+  "abi": [
+    {
+      "name": "close",
+      "inputs": []
+    },
+    {
+      "name": "pay",
+      "inputs": []
+    }
+  ],
+  "bytecode": "OP_4 OP_PICK OP_0 OP_NUMEQUAL OP_IF OP_0 OP_0 OP_BEGIN OP_DUP OP_UTXOTOKENCATEGORY OP_3 OP_PICK OP_EQUAL OP_IF OP_1 OP_ROT OP_DROP OP_SWAP OP_ENDIF OP_DUP OP_1ADD OP_NIP OP_DUP OP_TXINPUTCOUNT OP_LESSTHAN OP_2 OP_PICK OP_NOT OP_BOOLAND OP_NOT OP_UNTIL OP_SWAP OP_VERIFY OP_0 OP_BEGIN OP_DUP OP_OUTPUTTOKENCATEGORY OP_5 OP_PICK OP_EQUAL OP_NOT OP_VERIFY OP_DUP OP_1ADD OP_NIP OP_DUP OP_TXOUTPUTCOUNT OP_GREATERTHANOREQUAL OP_UNTIL OP_2DROP OP_2DROP OP_2DROP OP_DROP OP_1 OP_ELSE OP_4 OP_ROLL OP_1 OP_NUMEQUALVERIFY OP_INPUTINDEX OP_UTXOBYTECODE OP_INPUTINDEX OP_OUTPUTBYTECODE OP_EQUALVERIFY OP_INPUTINDEX OP_UTXOTOKENCATEGORY OP_INPUTINDEX OP_OUTPUTTOKENCATEGORY OP_EQUALVERIFY OP_INPUTINDEX OP_UTXOTOKENCOMMITMENT OP_INPUTINDEX OP_OUTPUTTOKENCOMMITMENT OP_EQUALVERIFY OP_INPUTINDEX OP_UTXOTOKENCATEGORY OP_3 OP_ROLL OP_EQUAL OP_IF OP_INPUTINDEX OP_UTXOTOKENCOMMITMENT 20 OP_SPLIT OP_DUP OP_8 OP_SPLIT OP_DUP OP_SIZE OP_NIP OP_0 OP_GREATERTHAN OP_IF OP_INPUTINDEX OP_1ADD OP_OUTPUTBYTECODE OP_OVER OP_EQUALVERIFY OP_ELSE OP_INPUTINDEX OP_1ADD OP_OUTPUTBYTECODE OP_6 OP_PICK OP_EQUALVERIFY OP_ENDIF OP_3 OP_PICK OP_BIN2NUM OP_0 OP_NUMEQUAL OP_IF OP_INPUTINDEX OP_1ADD OP_OUTPUTVALUE OP_2 OP_PICK OP_BIN2NUM OP_NUMEQUALVERIFY OP_ELSE OP_INPUTINDEX OP_1ADD OP_OUTPUTTOKENCATEGORY OP_4 OP_PICK OP_EQUALVERIFY OP_INPUTINDEX OP_1ADD OP_OUTPUTTOKENAMOUNT OP_2 OP_PICK OP_BIN2NUM OP_NUMEQUALVERIFY OP_ENDIF OP_2DROP OP_2DROP OP_ELSE OP_INPUTINDEX OP_1ADD OP_OUTPUTBYTECODE OP_2 OP_PICK OP_EQUALVERIFY OP_INPUTINDEX OP_1ADD OP_OUTPUTVALUE OP_3 OP_PICK OP_NUMEQUALVERIFY OP_ENDIF OP_2DROP OP_DROP OP_1 OP_ENDIF",
+  "source": "pragma cashscript ~0.13.0;\r\n\r\n/**\r\n * FeeManager: Validates fee payments and routing\r\n * \r\n * Every fund transaction pays fees through this contract.\r\n * Validates that fees match their encoding and route to correct destination.\r\n * \r\n * Fee Token commitment format (stored in NFT):\r\n * [fee_category (32) | fee_amount (8) | fee_destination (variable)]\r\n * \r\n * Where:\r\n * - fee_category: 0x00 = Bitcoin satoshis, else = CashToken category\r\n * - fee_amount: Amount due (satoshis or token amount)\r\n * - fee_destination: Optional override destination (empty = use default)\r\n *   Note: Variable-length intentionally - allows forward compatibility with future address formats\r\n * \r\n * Authorization:\r\n * - close() requires authToken to be present (protocol steward only)\r\n * - pay() validates the chosen fee is paid and routed\r\n * \r\n * Parameters:\r\n *   authToken: Authorization token category (controls who can close)\r\n *   destination: Default fee destination address (until override)\r\n *   feeToken: Fee token category (with expected 'none' capability)\r\n *   defaultValue: Default fee amount in satoshis (if no fee token encoding)\r\n */\r\ncontract FeeManager(bytes32 authToken, bytes destination, bytes32 feeToken, int defaultValue)\r\n{\r\n    /**\r\n     * close(): Close this fee by burning all fee tokens\r\n     * \r\n     * Allows protocol steward (authToken holder) to close the manager and cleanup.\r\n     * Ensures no active fee tokens remain (no dangling fees).\r\n     * \r\n     * Validates:\r\n     * - Transaction includes authToken (proves authorization)\r\n     * - No FeeManager fee tokens exist in any output (burned)\r\n     * \r\n     * Used at fund wind-down when all fees have been collected.\r\n     */\r\n    function close() {\r\n        // Check for authorization token in any input\r\n        bool authorized = false;\r\n        int inputIndex = 0;\r\n        do {\r\n            if(tx.inputs[inputIndex].tokenCategory == authToken) {\r\n                // Found authorization token - user is authorized to close\r\n                authorized = true;\r\n            }\r\n            inputIndex = inputIndex + 1;\r\n        } while(inputIndex < tx.inputs.length && !authorized);\r\n        require(authorized, \"unauthorized user\");\r\n\r\n        // Verify all fee tokens are burned (not present in any output)\r\n        int outputIndex = 0;\r\n        do {\r\n            // Prevent any output from receiving fee tokens (forces burn)\r\n            require(tx.outputs[outputIndex].tokenCategory != feeToken);\r\n            outputIndex = outputIndex + 1;\r\n        } while(outputIndex < tx.outputs.length);\r\n    }\r\n\r\n    /**\r\n     * pay(): Validate fee payment according to encoding\r\n     * \r\n     * Routes fee to destination encoded in fee token NFT or default destination.\r\n     * Supports two fee types: Bitcoin satoshis or CashTokens.\r\n     * \r\n     * Validates:\r\n     * - This FeeManager UTXO returns to itself (no state change)\r\n     * - Fee amount matches encoding (satoshis or token amount)\r\n     * - Fee routes to correct destination (from encoding or default)\r\n     * - Token category (if token fee) matches encoding\r\n     * \r\n     * Transaction Structure:\r\n     * Input[activeInputIndex]: This FeeManager with fee token\r\n     * Output[activeInputIndex]: This FeeManager (self-return)\r\n     * Output[activeInputIndex+1]: Fee payment to destination\r\n     * \r\n     * Fee Encoding Logic:\r\n     * - If fee_category == 0x00: Pay satoshis = fee_amount\r\n     * - If fee_category != 0x00: Pay tokens = fee_amount of fee_category\r\n     * - If fee_destination present: Pay to fee_destination\r\n     * - Else: Pay to default destination\r\n     */\r\n    function pay() {\r\n        // This FeeManager must return to itself (no state change)\r\n        require(tx.inputs[this.activeInputIndex].lockingBytecode == tx.outputs[this.activeInputIndex].lockingBytecode);\r\n        // Preserve fee token category for continuation\r\n        require(tx.inputs[this.activeInputIndex].tokenCategory == tx.outputs[this.activeInputIndex].tokenCategory);\r\n        // Preserve fee token NFT commitment (maintains encoding)\r\n        require(tx.inputs[this.activeInputIndex].nftCommitment == tx.outputs[this.activeInputIndex].nftCommitment);\r\n\r\n        // Extract fee parameters from NFT commitment if this is fee token\r\n        if(tx.inputs[this.activeInputIndex].tokenCategory == feeToken) {\r\n            // Decode fee commitment: [category | amount | destination]\r\n            bytes fee_category, bytes fee_next1 = tx.inputs[this.activeInputIndex].nftCommitment.split(32);\r\n            bytes fee_amount, bytes fee_destination = fee_next1.split(8);\r\n\r\n            // Determine fee destination (override or default)\r\n            if(fee_destination.length > 0) {\r\n                // Fee override destination specified in encoding\r\n                require(tx.outputs[this.activeInputIndex + 1].lockingBytecode == fee_destination);\r\n            } else {\r\n                // No override - use default destination\r\n                require(tx.outputs[this.activeInputIndex + 1].lockingBytecode == destination);\r\n            }\r\n            \r\n            // Validate fee amount and type\r\n            if(int(fee_category) == 0) {\r\n                // Category 0 = Bitcoin satoshis (not tokens)\r\n                // Output must have exact satoshi amount as encoded\r\n                require(tx.outputs[this.activeInputIndex + 1].value == int(fee_amount));\r\n            } else {\r\n                // Non-zero category = CashToken fee type\r\n                // Output must have correct token category and amount\r\n                require(tx.outputs[this.activeInputIndex + 1].tokenCategory == fee_category);\r\n                require(tx.outputs[this.activeInputIndex + 1].tokenAmount == int(fee_amount));\r\n            }\r\n        } else {\r\n            // No fee token encoding - use default values\r\n            // Pay default satoshi amount to default destination\r\n            require(tx.outputs[this.activeInputIndex + 1].lockingBytecode == destination);\r\n            require(tx.outputs[this.activeInputIndex + 1].value == defaultValue);\r\n        }\r\n    }\r\n}\r\n",
+  "debug": {
+    "bytecode": "5479009c6300006576ce53798763517b757c68768b7776c39f5279919a91667c69006576d15579879169768b7776c4a2666d6d6d755167547a519dc0c7c0cd88c0cec0d188c0cfc0d288c0ce537a8763c0cf01207f76587f76827700a063c08bcd788867c08bcd56798868537981009c63c08bcc5279819d67c08bd1547988c08bd35279819d686d6d67c08bcd527988c08bcc53799d686d755168",
+    "sourceMap": "42:4:62:5;;;;;44:26:44:31;45:25:45:26;46:8:52:62;47:25:47:35;:15::50:1;:54::63:0;;:15:::1;:65:50:13:0;49:29:49:33;:16::34:1;;;47:65:50:13;51:25:51:35:0;:::39:1;:12::40;52:16:52:26:0;:29::45;:16:::1;:50::60:0;;:49:::1;:16;46:8::62;;53:16:53:26:0;:8::49:1;56:26:56:27:0;57:8:61:49;59:31:59:42;:20::57:1;:61::69:0;;:20:::1;;:12::71;60:26:60:37:0;:::41:1;:12::42;61:16:61:27:0;:30::47;57:8::49:1;;42:4:62:5;;;;;;87::127::0;;;;89:26:89:47;:16::64:1;:79::100:0;:68::117:1;:8::119;91:26:91:47:0;:16::62:1;:77::98:0;:66::113:1;:8::115;93:26:93:47:0;:16::62:1;:77::98:0;:66::113:1;:8::115;96:21:96:42:0;:11::57:1;:61::69:0;;:11:::1;:71:121:9:0;98:60:98:81;:50::96:1;:103::105:0;:50::106:1;99:54:99:63:0;:70::71;:54::72:1;102:15:102:30:0;:::37:1;;:40::41:0;:15:::1;:43:105:13:0;104:35:104:56;:::60:1;:24::77;:81::96:0;:16::98:1;105:19:108:13:0;107:35:107:56;:::60:1;:24::77;:81::92:0;;:16::94:1;105:19:108:13;111::111:31:0;;:15::32:1;:36::37:0;:15:::1;:39:115:13:0;114:35:114:56;:::60:1;:24::67;:75::85:0;;:71::86:1;:16::88;115:19:120:13:0;118:35:118:56;:::60:1;:24::75;:79::91:0;;:16::93:1;119:35:119:56:0;:::60:1;:24::73;:81::91:0;;:77::92:1;:16::94;115:19:120:13;96:71:121:9;;121:15:126::0;124:31:124:52;:::56:1;:20::73;:77::88:0;;:12::90:1;125:31:125:52:0;:::56:1;:20::63;:67::79:0;;:12::81:1;121:15:126:9;87:4:127:5;;;28:0:128:1",
+    "logs": [],
+    "requires": [
+      {
+        "ip": 36,
+        "line": 53,
+        "message": "unauthorized user"
+      },
+      {
+        "ip": 45,
+        "line": 59
+      },
+      {
+        "ip": 67,
+        "line": 89
+      },
+      {
+        "ip": 72,
+        "line": 91
+      },
+      {
+        "ip": 77,
+        "line": 93
+      },
+      {
+        "ip": 101,
+        "line": 104
+      },
+      {
+        "ip": 108,
+        "line": 107
+      },
+      {
+        "ip": 122,
+        "line": 114
+      },
+      {
+        "ip": 129,
+        "line": 118
+      },
+      {
+        "ip": 136,
+        "line": 119
+      },
+      {
+        "ip": 146,
+        "line": 124
+      },
+      {
+        "ip": 152,
+        "line": 125
+      }
+    ]
+  },
+  "compiler": {
+    "name": "cashc",
+    "version": "0.13.0-next.6",
+    "options": {
+      "enforceFunctionParameterTypes": true
+    }
+  },
+  "updatedAt": "2026-04-21T19:21:05.225Z"
+}

package/art/fee_minter.json

@@ -0,0 +1,82 @@
+{
+  "contractName": "FeeMinter",
+  "constructorInputs": [
+    {
+      "name": "authorization",
+      "type": "bytes32"
+    },
+    {
+      "name": "token",
+      "type": "bytes32"
+    },
+    {
+      "name": "destination",
+      "type": "bytes"
+    }
+  ],
+  "abi": [
+    {
+      "name": "mint",
+      "inputs": []
+    }
+  ],
+  "bytecode": "OP_INPUTINDEX OP_UTXOTOKENCATEGORY 20 OP_SPLIT OP_DROP OP_2 OP_PICK OP_EQUALVERIFY OP_INPUTINDEX OP_UTXOBYTECODE OP_INPUTINDEX OP_OUTPUTBYTECODE OP_EQUALVERIFY OP_INPUTINDEX OP_UTXOTOKENCATEGORY OP_INPUTINDEX OP_OUTPUTTOKENCATEGORY OP_EQUALVERIFY OP_INPUTINDEX OP_UTXOTOKENCOMMITMENT OP_INPUTINDEX OP_OUTPUTTOKENCOMMITMENT OP_EQUALVERIFY OP_0 OP_0 OP_BEGIN OP_DUP OP_UTXOTOKENCATEGORY OP_3 OP_PICK OP_EQUAL OP_IF OP_1 OP_ROT OP_DROP OP_SWAP OP_ENDIF OP_DUP OP_1ADD OP_NIP OP_DUP OP_TXINPUTCOUNT OP_LESSTHAN OP_2 OP_PICK OP_NOT OP_BOOLAND OP_NOT OP_UNTIL OP_SWAP OP_VERIFY OP_0 OP_BEGIN OP_DUP OP_INPUTINDEX OP_NUMNOTEQUAL OP_OVER OP_OUTPUTTOKENCATEGORY OP_0 OP_EQUAL OP_NOT OP_BOOLAND OP_IF OP_DUP OP_OUTPUTTOKENCATEGORY 20 OP_SPLIT OP_DROP OP_4 OP_PICK OP_EQUAL OP_IF OP_DUP OP_OUTPUTBYTECODE OP_5 OP_PICK OP_EQUALVERIFY OP_DUP OP_OUTPUTTOKENCATEGORY OP_4 OP_PICK OP_EQUALVERIFY OP_DUP OP_OUTPUTTOKENCOMMITMENT OP_SIZE OP_NIP OP_0 OP_GREATERTHAN OP_VERIFY OP_DUP OP_OUTPUTTOKENCOMMITMENT 20 OP_SPLIT OP_OVER OP_0 OP_EQUAL OP_NOT OP_VERIFY OP_DUP OP_8 OP_SPLIT OP_DROP OP_DUP OP_BIN2NUM OP_0 OP_GREATERTHAN OP_VERIFY OP_2DROP OP_DROP OP_ENDIF OP_ENDIF OP_DUP OP_1ADD OP_NIP OP_DUP OP_TXOUTPUTCOUNT OP_GREATERTHANOREQUAL OP_UNTIL OP_2DROP OP_2DROP OP_DROP OP_1",
+  "source": "pragma cashscript ~0.13.0;\r\n\r\n/**\r\n * FeeMinter: Authorization-controlled fee token minting with encoded fee commitments\r\n * \r\n * Similar to SimpleMinter, but allows encoding fee details in NFT commitments.\r\n * Fee tokens carry commitment data: [category | amount | destination_override]\r\n * Used to create tokens that encode specific fee amounts and routing.\r\n * \r\n * Destination override is variable-length by design - allows forward compatibility\r\n * with future address formats or multisig patterns without redeploying contract.\r\n * \r\n * Parameters:\r\n *   authorization: Token category that authorizes minting\r\n *   token: Fee token category being minted\r\n *   destination: Default destination for fee payments\r\n */\r\ncontract FeeMinter(bytes32 authorization, bytes32 token, bytes destination)\r\n{\r\n    /**\r\n     * mint(): Mints fee tokens with commitment encoding\r\n     * \r\n     * Fee commitment format: [fee_category (32) | fee_amount (8) | destination_override (0+)]\r\n     * - Category: 0x00 = Bitcoin satoshis, else = token category\r\n     * - Amount: int64 LE integer\r\n     * - Destination: Optional locking bytecode override for fee routing\r\n     */\r\n    function mint() {\r\n        // Verify this is a fee minting token\r\n        require(tx.inputs[this.activeInputIndex].tokenCategory.slice(0, 32) == token);\r\n\r\n        // Contract returns to itself (locked pattern)\r\n        require(tx.inputs[this.activeInputIndex].lockingBytecode == tx.outputs[this.activeInputIndex].lockingBytecode);\r\n        \r\n        // Keep the fee minting token\r\n        require(tx.inputs[this.activeInputIndex].tokenCategory == tx.outputs[this.activeInputIndex].tokenCategory);\r\n        \r\n        // Preserve NFT commitment (minting capability)\r\n        require(tx.inputs[this.activeInputIndex].nftCommitment == tx.outputs[this.activeInputIndex].nftCommitment);\r\n\r\n\r\n        // Require owner authorization\r\n        bool authorized = false;\r\n        int inputIndex = 0;\r\n        do {\r\n            if(tx.inputs[inputIndex].tokenCategory == authorization) {\r\n                authorized = true;\r\n            }\r\n            inputIndex = inputIndex + 1;\r\n        } while(inputIndex < tx.inputs.length && !authorized);\r\n        require(authorized, \"unauthorized user\");\r\n\r\n\r\n        // Verify all outputs minting fee tokens have proper commitment\r\n        int outputIndex = 0;\r\n        do {\r\n            if(outputIndex != this.activeInputIndex && tx.outputs[outputIndex].tokenCategory != 0x) {\r\n                if(tx.outputs[outputIndex].tokenCategory.slice(0, 32) == token) {\r\n                    // Fee tokens go to the destination\r\n                    require(tx.outputs[outputIndex].lockingBytecode == destination);\r\n                    require(tx.outputs[outputIndex].tokenCategory == token);\r\n\r\n                    // Fee token MUST have a commitment encoding fee details\r\n                    require(tx.outputs[outputIndex].nftCommitment.length > 0, \"must provide a commitment\");\r\n                    \r\n                    // Parse commitment: [fee_category | fee_amount | destination_override]\r\n                    bytes fee_category, bytes fee_next1 = tx.outputs[outputIndex].nftCommitment.split(32);\r\n                    // Fee category must be specified (0x00 for Bitcoin, or token category)\r\n                    require(fee_category != 0x);\r\n                    \r\n                    bytes fee_amount = fee_next1.slice(0, 8);\r\n                    // Fee amount must be positive\r\n                    require(int(fee_amount) > 0);\r\n                    // Destination is optional (0x for default, or locking bytecode)\r\n                }\r\n            }\r\n            outputIndex = outputIndex + 1;\r\n        } while(outputIndex < tx.outputs.length);\r\n    }\r\n}",
+  "debug": {
+    "bytecode": "c0ce01207f75527988c0c7c0cd88c0cec0d188c0cfc0d28800006576ce53798763517b757c68768b7776c39f5279919a91667c69006576c09e78d10087919a6376d101207f755479876376cd55798876d154798876d2827700a06976d201207f780087916976587f75768100a0696d756868768b7776c4a2666d6d7551",
+    "sourceMap": "30:26:30:47;:16::62:1;:72::74:0;:16::75:1;;:79::84:0;;:8::86:1;33:26:33:47:0;:16::64:1;:79::100:0;:68::117:1;:8::119;36:26:36:47:0;:16::62:1;:77::98:0;:66::113:1;:8::115;39:26:39:47:0;:16::62:1;:77::98:0;:66::113:1;:8::115;43:26:43:31:0;44:25:44:26;45:8:50:62;46:25:46:35;:15::50:1;:54::67:0;;:15:::1;:69:48:13:0;47:29:47:33;:16::34:1;;;46:69:48:13;49:25:49:35:0;:::39:1;:12::40;50:16:50:26:0;:29::45;:16:::1;:50::60:0;;:49:::1;:16;45:8::62;;51:16:51:26:0;:8::49:1;55:26:55:27:0;56:8:78:49;57:15:57:26;:30::51;:15:::1;:66::77:0;:55::92:1;:96::98:0;:55:::1;;:15;:100:76:13:0;58:30:58:41;:19::56:1;:66::68:0;:19::69:1;;:73::78:0;;:19:::1;:80:75:17:0;60:39:60:50;:28::67:1;:71::82:0;;:20::84:1;61:39:61:50:0;:28::65:1;:69::74:0;;:20::76:1;64:39:64:50:0;:28::65:1;:::72;;:75::76:0;:28:::1;:20::107;67:69:67:80:0;:58::95:1;:102::104:0;:58::105:1;69:28:69:40:0;:44::46;:28:::1;;:20::48;71:39:71::0;:58::59;:39::60:1;;73:32:73:42:0;:28::43:1;:46::47:0;:28:::1;:20::49;58:80:75:17;;;57:100:76:13;77:26:77:37:0;:::41:1;:12::42;78:16:78:27:0;:30::47;56:8::49:1;;28:4:79:5;;;",
+    "logs": [],
+    "requires": [
+      {
+        "ip": 10,
+        "line": 30
+      },
+      {
+        "ip": 15,
+        "line": 33
+      },
+      {
+        "ip": 20,
+        "line": 36
+      },
+      {
+        "ip": 25,
+        "line": 39
+      },
+      {
+        "ip": 53,
+        "line": 51,
+        "message": "unauthorized user"
+      },
+      {
+        "ip": 79,
+        "line": 60
+      },
+      {
+        "ip": 84,
+        "line": 61
+      },
+      {
+        "ip": 91,
+        "line": 64,
+        "message": "must provide a commitment"
+      },
+      {
+        "ip": 100,
+        "line": 69
+      },
+      {
+        "ip": 109,
+        "line": 73
+      }
+    ]
+  },
+  "compiler": {
+    "name": "cashc",
+    "version": "0.13.0-next.6",
+    "options": {
+      "enforceFunctionParameterTypes": true
+    }
+  },
+  "updatedAt": "2026-04-21T19:21:07.014Z"
+}