@frontiercompute/zcash-ika 0.2.0 → 0.3.0

package/README.md

@@ -1,28 +1,31 @@
 # zcash-ika
 
-Split-key custody for Zcash, Bitcoin, and EVM chains. The private key never exists whole.
+Split-key custody for Zcash, Bitcoin, and EVM chains. The private key never exists whole. Spend policy enforced on-chain. Every action attested to Zcash.
 
 [![npm](https://img.shields.io/npm/v/@frontiercompute/zcash-ika)](https://www.npmjs.com/package/@frontiercompute/zcash-ika)
 
-## What this is
+## What this does
 
-One secp256k1 dWallet on [Ika's 2PC-MPC network](https://ika.xyz) signs for Zcash transparent, Bitcoin, and Ethereum. Your device holds half the key. Ika's nodes hold the other half. Spending policy enforced by Sui Move contract. Every action attested on Zcash via [ZAP1](https://pay.frontiercompute.io).
+One secp256k1 dWallet on [Ika's 2PC-MPC network](https://ika.xyz) signs for three chain families. Your device holds half the key. Ika's nodes hold the other half. Neither can spend alone.
 
-## What works today
+- **Spend policy** enforced by Sui Move contract (per-tx limits, daily caps, recipient whitelist, emergency freeze)
+- **Transparent TX builder** for Zcash v5 transactions (ZIP 244 sighash, P2PKH, UTXO selection)
+- **Attestation** of every operation to Zcash mainnet via [ZAP1](https://pay.frontiercompute.io)
+- **5-chain verification** of attestation proofs (Arbitrum, Base, Hyperliquid, Solana, NEAR)
+
+## Chain support
 
 | Chain | Curve | Algorithm | Hash | Status |
 |-------|-------|-----------|------|--------|
-| Zcash transparent | secp256k1 | ECDSA | DoubleSHA256 | dWallet on testnet, signing wired |
-| Bitcoin | secp256k1 | ECDSA | DoubleSHA256 | Same dWallet, same key |
-| Ethereum/EVM | secp256k1 | ECDSA | KECCAK256 | Same dWallet, different hash |
+| Zcash transparent | secp256k1 | ECDSA | DoubleSHA256 | TX builder + signing live |
+| Bitcoin | secp256k1 | ECDSA | DoubleSHA256 | Same dWallet, signing live |
+| Ethereum/EVM | secp256k1 | ECDSA | KECCAK256 | Same dWallet, signing live |
 
 One dWallet. Three chain families. Split custody on all of them.
 
 ## What does NOT work
 
-**Zcash shielded (Orchard)** requires RedPallas signatures on the Pallas curve. Ika's MPC supports secp256k1 and Ed25519, but not Pallas. There is no path from Ika to Orchard signing today. Same for Sapling (RedJubjub on Jubjub).
-
-For shielded operations, use the [embedded Orchard wallet](https://github.com/Frontier-Compute/zap1) which holds keys directly. The hybrid architecture: MPC custody for transparent + cross-chain, local wallet for shielded.
+**Zcash shielded (Orchard)** requires RedPallas on the Pallas curve. Ika supports secp256k1 and Ed25519, not Pallas. No path from Ika to Orchard signing today. For shielded, use the [embedded wallet](https://github.com/Frontier-Compute/zap1) which holds Orchard keys directly.
 
 ## Install
 
@@ -30,16 +33,16 @@ For shielded operations, use the [embedded Orchard wallet](https://github.com/Fr
 npm install @frontiercompute/zcash-ika
 ```
 
-## Usage
+## Quick start
 
 ```typescript
 import {
   createWallet,
   sign,
-  createDualCustody,
-  getHistory,
-  checkCompliance,
-  CHAIN_PARAMS,
+  setPolicy,
+  spendTransparent,
+  checkPolicy,
+  deriveZcashAddress,
 } from "@frontiercompute/zcash-ika";
 
 const config = {
@@ -48,81 +51,129 @@ const config = {
   zap1ApiUrl: "https://pay.frontiercompute.io",
 };
 
-// Create split-key wallet (secp256k1 - signs for ZEC + BTC + ETH)
-const custody = await createDualCustody(config);
-console.log("dWallet:", custody.primary.id);
-console.log("Save this seed:", custody.primary.encryptionSeed);
-
-// Sign a Zcash transparent sighash through MPC
-const result = await sign(config, {
-  messageHash: sighashBytes, // DoubleSHA256 of the tx
-  walletId: custody.primary.id,
-  chain: "zcash-transparent",
-  encryptionSeed: custody.primary.encryptionSeed,
-});
-console.log("Signature:", Buffer.from(result.signature).toString("hex"));
-
-// Sign Bitcoin (same dWallet, same MPC, same seed)
-const btcSig = await sign(config, {
-  messageHash: btcSighash,
-  walletId: custody.primary.id,
-  chain: "bitcoin",
-  encryptionSeed: custody.primary.encryptionSeed,
+// 1. Create split-key wallet
+const wallet = await createWallet(config);
+console.log("dWallet:", wallet.id);
+console.log("t-addr:", wallet.address);
+console.log("Save this seed:", wallet.encryptionSeed);
+
+// 2. Set spend policy (Sui Move contract)
+const policy = await setPolicy(config, wallet.id, {
+  maxPerTx: 100_000_000,       // 1 ZEC max per transaction
+  maxDaily: 500_000_000,       // 5 ZEC daily cap
+  allowedRecipients: [],       // empty = any recipient
+  approvalThreshold: 50_000_000, // flag above 0.5 ZEC
 });
+console.log("Policy:", policy.policyId);
 
-// Compliance check (works now against live ZAP1 API)
-const compliance = await checkCompliance(config, custody.primary.id);
+// 3. Check if a spend is allowed
+const check = await checkPolicy(config, policy.policyId, {
+  amount: 10_000_000,
+  recipient: "t1SomeAddress...",
+});
+console.log("Allowed:", check.allowed);
+
+// 4. Spend from the transparent address
+const spend = await spendTransparent(config, {
+  walletId: wallet.id,
+  encryptionSeed: wallet.encryptionSeed,
+  recipient: "t1RecipientAddr...",
+  amount: 10_000_000,   // 0.1 ZEC
+  zebraRpcUrl: "http://localhost:8232",
+});
+console.log("Txid:", spend.txid);
 ```
 
-## How it works
+## Architecture
 
 ```
-Operator (phone / hardware wallet)
+Operator (device / HSM)
   |
-  | user key share (encryption seed)
+  | user key share (encryption seed from DKG)
   |
 Ika MPC Network (2PC-MPC on Sui)
   |
   | network key share (distributed across nodes)
   |
-  +-- Spending Policy (Sui Move contract)
-  |     max per tx, daily cap, approved recipients
+  +-- Spend Policy (Sui Move contract)
+  |     max per tx, daily cap, recipient whitelist, freeze
   |
-  +-- Sign ZEC transparent tx (secp256k1/ECDSA/DoubleSHA256)
-  +-- Sign BTC tx             (secp256k1/ECDSA/DoubleSHA256)
-  +-- Sign ETH tx             (secp256k1/ECDSA/KECCAK256)
+  +-- Sign ZEC transparent  (secp256k1 / ECDSA / DoubleSHA256)
+  +-- Sign BTC              (secp256k1 / ECDSA / DoubleSHA256)
+  +-- Sign ETH/EVM          (secp256k1 / ECDSA / KECCAK256)
+  |
+TX Builder (Zcash v5, ZIP 244)
+  +-- UTXO fetch from Zebra
+  +-- Sighash computation
+  +-- Signature attachment
+  +-- Broadcast + attestation
   |
 ZAP1 Attestation (Zcash mainnet)
-  +-- every spend recorded
-  +-- policy violations on-chain
-  +-- full audit trail
+  +-- every spend recorded in Merkle tree
+  +-- anchored to Zcash blockchain
+  +-- verified on 5 EVM/L1 chains
 ```
 
-## Sign flow (two transactions)
+## Sign flow
+
+1. **Presign** - pre-compute MPC ephemeral key share (Sui TX 1, poll for completion)
+2. **Sign** - approve message + request signature (Sui TX 2, poll for completion)
+
+Both transactions on Sui. The user partial is computed locally via WASM. Neither party sees the full private key.
+
+## Spend flow (transparent)
 
-1. **Presign** - pre-compute MPC ephemeral key share (TX 1, poll for completion)
-2. **Sign** - approve message + request signature (TX 2, poll for completion)
+1. Fetch UTXOs from Zebra RPC (`getaddressutxos`)
+2. Build unsigned v5 TX with ZIP 244 sighash per input
+3. Sign each sighash through Ika MPC (presign + sign)
+4. Attach DER signatures to scriptSig fields
+5. Broadcast via `sendrawtransaction`
+6. Attest spend to ZAP1
 
-Both transactions on Sui. The user partial signature is computed locally via WASM. Neither party ever sees the full private key.
+## Policy enforcement
+
+The Sui Move contract (`zap1_policy::policy`) stores:
+- Per-transaction limit (zatoshis)
+- 24-hour rolling daily cap
+- Allowed recipient whitelist (empty = any)
+- Emergency freeze toggle
+
+Policy is checked before every MPC sign request. The contract owns the approval gate - you can't bypass it from the client.
+
+Deploy: `sui client publish --path move/` then set `POLICY_PACKAGE_ID`.
 
 ## On-chain proof
 
-secp256k1 dWallet created on Ika testnet:
+secp256k1 dWallet on Ika testnet:
 
 - dWalletId: `0xd9055400c88aeae675413b78143aa54e25eca7061ab659f54a42167cbfdd7aec`
 - TX: [`CYrS5X1S3itHUtux4qS35AJz5AAyUaJYeWZuqm1CcX2L`](https://testnet.suivision.xyz/txblock/CYrS5X1S3itHUtux4qS35AJz5AAyUaJYeWZuqm1CcX2L)
-- Public key: `03ba9e85a85674df494520c2e80b804656fac54fe68668266f33fee9b03ad4b069`
-- Derived BTC: `moV3JAzgNa6NkxVfdaNqUjLoDxKEwNAnkX`
+- Compressed pubkey: `03ba9e85a85674df494520c2e80b804656fac54fe68668266f33fee9b03ad4b069`
 - Derived ZEC t-addr: `t1Rqh1TKqXsSiaV4wrSDandEPccucpHEudn`
 
+Attestation anchors verified on Arbitrum, Base, Hyperliquid, Solana, NEAR testnet.
+
+## Environment variables
+
+```
+SUI_PRIVATE_KEY         - Sui keypair for signing transactions
+POLICY_PACKAGE_ID       - Published Move package address (after sui client publish)
+ZAP1_API_URL            - ZAP1 attestation API (default: https://pay.frontiercompute.io)
+ZAP1_API_KEY            - API key for attestation
+ZEBRA_RPC_URL           - Zebra JSON-RPC endpoint for UTXO queries and broadcast
+```
+
 ## Test scripts
 
 ```bash
-# Create a new dWallet (saves encryption seed)
+# Create a new dWallet
 SUI_PRIVATE_KEY=suiprivkey1... node dist/test-dkg.js
 
 # Sign a test message through MPC
 SUI_PRIVATE_KEY=... DWALLET_ID=0x... ENC_SEED=... node dist/test-sign.js
+
+# End-to-end: DKG + presign + sign
+SUI_PRIVATE_KEY=... node dist/test-e2e.js
 ```
 
 ## Stack
@@ -130,6 +181,7 @@ SUI_PRIVATE_KEY=... DWALLET_ID=0x... ENC_SEED=... node dist/test-sign.js
 - [Ika](https://ika.xyz) - 2PC-MPC threshold signing on Sui
 - [ZAP1](https://pay.frontiercompute.io) - on-chain attestation protocol
 - [Zebra](https://github.com/ZcashFoundation/zebra) - Zcash node
+- [Sui Move](https://docs.sui.io/concepts/sui-move-concepts) - policy enforcement
 
 ## License
 

package/dist/index.d.ts

@@ -14,6 +14,8 @@
  * is viable through this package today.
  */
 export { Curve, Hash, SignatureAlgorithm, IkaClient, IkaTransaction, UserShareEncryptionKeys, getNetworkConfig, createClassGroupsKeypair, createRandomSessionIdentifier, prepareDKG, prepareDKGAsync, prepareDKGSecondRound, prepareDKGSecondRoundAsync, createDKGUserOutput, publicKeyFromDWalletOutput, parseSignatureFromSignOutput, } from "@ika.xyz/sdk";
+export { fetchUTXOs, selectUTXOs, buildUnsignedTx, attachSignatures, broadcastTx, estimateFee, BRANCH_ID, } from "./tx-builder.js";
+export type { UTXO } from "./tx-builder.js";
 export type Chain = "zcash-transparent" | "bitcoin" | "ethereum";
 export interface ZcashIkaConfig {
     /** Ika network: mainnet or testnet */
@@ -167,21 +169,48 @@ export declare function createWallet(config: ZcashIkaConfig, chain: Chain, _oper
  * Neither party ever sees the full private key.
  */
 export declare function sign(config: ZcashIkaConfig, request: SignRequest): Promise<SignResult>;
+export interface PolicyResult {
+    /** SpendPolicy shared object ID on Sui */
+    policyId: string;
+    /** PolicyCap object ID (owner holds this to manage policy) */
+    capId: string;
+    /** Sui transaction digest */
+    txDigest: string;
+}
+export interface PolicyState {
+    policyId: string;
+    dwalletId: string;
+    owner: string;
+    maxPerTx: number;
+    maxDaily: number;
+    dailySpent: number;
+    windowStart: number;
+    allowedRecipients: string[];
+    frozen: boolean;
+}
+/**
+ * Set spending policy on a dWallet.
+ * Creates a SpendPolicy shared object and PolicyCap on Sui.
+ * The PolicyCap is transferred to the caller.
+ */
+export declare function setPolicy(config: ZcashIkaConfig, walletId: string, policy: SpendPolicy): Promise<PolicyResult>;
 /**
- * Set spending policy on the dWallet.
- * Policy enforced at Sui Move contract level.
- * The agent cannot bypass it - the contract holds the DWalletCap.
+ * Query a SpendPolicy object and check if a spend would be allowed.
+ * Returns the full policy state plus a boolean for the specific check.
  */
-export declare function setPolicy(_config: ZcashIkaConfig, _walletId: string, _policy: SpendPolicy): Promise<string>;
+export declare function checkPolicy(config: ZcashIkaConfig, policyId: string, amount?: number, recipient?: string): Promise<PolicyState & {
+    allowed: boolean;
+}>;
 /**
  * Spend from a Zcash transparent wallet.
  *
- * 1. Build Zcash transparent transaction (requires Zebra)
- * 2. Compute sighash (DoubleSHA256)
- * 3. Sign via Ika 2PC-MPC (secp256k1/ECDSA)
- * 4. Attach signature to transaction
+ * Full pipeline:
+ * 1. Fetch UTXOs from Zebra
+ * 2. Build unsigned TX, compute ZIP 244 sighashes
+ * 3. Sign each sighash via Ika 2PC-MPC
+ * 4. Attach signatures, serialize signed TX
  * 5. Broadcast via Zebra sendrawtransaction
- * 6. Attest via ZAP1 as AGENT_ACTION
+ * 6. Attest to ZAP1 as AGENT_ACTION
  */
 export declare function spendTransparent(config: ZcashIkaConfig, walletId: string, encryptionSeed: string, request: SpendRequest): Promise<SpendResult>;
 /**

package/dist/index.js

@@ -19,6 +19,8 @@ import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { Transaction } from "@mysten/sui/transactions";
 import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
 import { createHash } from "node:crypto";
+import { fetchUTXOs, selectUTXOs, buildUnsignedTx, attachSignatures, broadcastTx, estimateFee, BRANCH_ID, } from "./tx-builder.js";
+export { fetchUTXOs, selectUTXOs, buildUnsignedTx, attachSignatures, broadcastTx, estimateFee, BRANCH_ID, } from "./tx-builder.js";
 const IKA_COIN_TYPE = "0x1f26bb2f711ff82dcda4d02c77d5123089cb7f8418751474b9fb744ce031526a::ika::IKA";
 /** Parameters for dWallet creation per chain.
  *
@@ -471,33 +473,239 @@ export async function sign(config, request) {
         signTxDigest: signResult.digest,
     };
 }
+// Published package ID - set after sui client publish
+// Override via POLICY_PACKAGE_ID env var or pass directly
+const DEFAULT_POLICY_PACKAGE_ID = "0x0";
+function getPolicyPackageId() {
+    return process.env.POLICY_PACKAGE_ID || DEFAULT_POLICY_PACKAGE_ID;
+}
+/**
+ * Set spending policy on a dWallet.
+ * Creates a SpendPolicy shared object and PolicyCap on Sui.
+ * The PolicyCap is transferred to the caller.
+ */
+export async function setPolicy(config, walletId, policy) {
+    const packageId = getPolicyPackageId();
+    if (packageId === "0x0") {
+        throw new Error("Policy Move module not deployed. Set POLICY_PACKAGE_ID env var " +
+            "after running: sui client publish --path move/");
+    }
+    const { suiClient, keypair } = await initClients(config);
+    const tx = new Transaction();
+    // 0x6 is the shared Clock object on Sui
+    const cap = tx.moveCall({
+        target: `${packageId}::policy::create_policy`,
+        arguments: [
+            tx.pure.address(walletId),
+            tx.pure.u64(policy.maxPerTx),
+            tx.pure.u64(policy.maxDaily),
+            tx.object("0x6"),
+        ],
+    });
+    // Transfer the returned PolicyCap to sender
+    const sender = keypair.getPublicKey().toSuiAddress();
+    tx.transferObjects([cap], sender);
+    // Add allowed recipients if any
+    // Done in separate calls after creation since create_policy starts with empty list
+    const result = await suiClient.signAndExecuteTransaction({
+        transaction: tx,
+        signer: keypair,
+        options: { showEffects: true, showObjectChanges: true },
+    });
+    if (result.effects?.status?.status !== "success") {
+        throw new Error(`setPolicy TX failed: ${result.effects?.status?.error}`);
+    }
+    // Extract created object IDs
+    let policyId = "";
+    let capId = "";
+    const changes = result.objectChanges || [];
+    for (const change of changes) {
+        if (change.type !== "created")
+            continue;
+        const objType = change.objectType || "";
+        if (objType.includes("::policy::SpendPolicy")) {
+            policyId = change.objectId;
+        }
+        else if (objType.includes("::policy::PolicyCap")) {
+            capId = change.objectId;
+        }
+    }
+    if (!policyId || !capId) {
+        // Fallback: scan created effects
+        const created = result.effects?.created || [];
+        for (const obj of created) {
+            const id = obj.reference?.objectId || obj.objectId;
+            if (id && !policyId)
+                policyId = id;
+            else if (id && !capId)
+                capId = id;
+        }
+    }
+    // Add recipients in a second tx if needed
+    if (policy.allowedRecipients.length > 0 && policyId && capId) {
+        const tx2 = new Transaction();
+        for (const addr of policy.allowedRecipients) {
+            const addrBytes = new TextEncoder().encode(addr);
+            tx2.moveCall({
+                target: `${packageId}::policy::add_recipient_entry`,
+                arguments: [
+                    tx2.object(policyId),
+                    tx2.object(capId),
+                    tx2.pure.vector("u8", Array.from(addrBytes)),
+                ],
+            });
+        }
+        await suiClient.signAndExecuteTransaction({
+            transaction: tx2,
+            signer: keypair,
+            options: { showEffects: true },
+        });
+    }
+    return { policyId, capId, txDigest: result.digest };
+}
 /**
- * Set spending policy on the dWallet.
- * Policy enforced at Sui Move contract level.
- * The agent cannot bypass it - the contract holds the DWalletCap.
+ * Query a SpendPolicy object and check if a spend would be allowed.
+ * Returns the full policy state plus a boolean for the specific check.
  */
-export async function setPolicy(_config, _walletId, _policy) {
-    throw new Error("setPolicy requires a deployed Move module on Sui. " +
-        "The module gates approve_message() with spending constraints. " +
-        "See docs/move-policy-template.move for the template.");
+export async function checkPolicy(config, policyId, amount, recipient) {
+    const { suiClient } = await initClients(config);
+    const obj = await suiClient.getObject({
+        id: policyId,
+        options: { showContent: true },
+    });
+    const content = obj.data?.content;
+    if (!content || content.dataType !== "moveObject") {
+        throw new Error(`Policy object ${policyId} not found or not a Move object`);
+    }
+    const fields = content.fields;
+    const state = {
+        policyId,
+        dwalletId: fields.dwallet_id,
+        owner: fields.owner,
+        maxPerTx: Number(fields.max_per_tx),
+        maxDaily: Number(fields.max_daily),
+        dailySpent: Number(fields.daily_spent),
+        windowStart: Number(fields.window_start),
+        allowedRecipients: (fields.allowed_recipients || []).map((r) => new TextDecoder().decode(new Uint8Array(r))),
+        frozen: fields.frozen,
+    };
+    // Client-side policy check (mirrors Move logic)
+    let allowed = true;
+    if (state.frozen) {
+        allowed = false;
+    }
+    else if (amount !== undefined) {
+        if (amount > state.maxPerTx) {
+            allowed = false;
+        }
+        else {
+            const now = Date.now();
+            const daily = (now >= state.windowStart + 86_400_000) ? 0 : state.dailySpent;
+            if (daily + amount > state.maxDaily) {
+                allowed = false;
+            }
+        }
+        if (allowed && recipient && state.allowedRecipients.length > 0) {
+            allowed = state.allowedRecipients.includes(recipient);
+        }
+    }
+    return { ...state, allowed };
 }
 /**
  * Spend from a Zcash transparent wallet.
  *
- * 1. Build Zcash transparent transaction (requires Zebra)
- * 2. Compute sighash (DoubleSHA256)
- * 3. Sign via Ika 2PC-MPC (secp256k1/ECDSA)
- * 4. Attach signature to transaction
+ * Full pipeline:
+ * 1. Fetch UTXOs from Zebra
+ * 2. Build unsigned TX, compute ZIP 244 sighashes
+ * 3. Sign each sighash via Ika 2PC-MPC
+ * 4. Attach signatures, serialize signed TX
  * 5. Broadcast via Zebra sendrawtransaction
- * 6. Attest via ZAP1 as AGENT_ACTION
+ * 6. Attest to ZAP1 as AGENT_ACTION
  */
 export async function spendTransparent(config, walletId, encryptionSeed, request) {
-    // Build transaction, extract sighash
-    // For now: the caller provides the sighash directly via sign()
-    // This function will be the full pipeline once we have tx building
-    throw new Error("spendTransparent requires Zcash transparent tx builder. " +
-        "Use sign() directly with a pre-computed sighash for now. " +
-        "Full pipeline: build tx -> sighash -> sign() -> attach sig -> broadcast.");
+    const zebraUrl = config.zebraRpcUrl;
+    if (!zebraUrl) {
+        throw new Error("zebraRpcUrl required for transparent spend");
+    }
+    // Fetch the dWallet to get the public key
+    const { ikaClient } = await initClients(config);
+    const dWallet = await ikaClient.getDWallet(walletId);
+    if (!dWallet?.state?.Active) {
+        throw new Error(`dWallet ${walletId} not Active`);
+    }
+    const rawOutput = dWallet.state.Active.public_output;
+    const outputBytes = new Uint8Array(Array.isArray(rawOutput) ? rawOutput : Array.from(rawOutput));
+    const pubkey = await publicKeyFromDWalletOutput(Curve.SECP256K1, outputBytes);
+    if (!pubkey || pubkey.length !== 33) {
+        throw new Error("Could not extract 33-byte compressed pubkey from dWallet");
+    }
+    // Derive our t-address from the pubkey
+    const ourAddress = deriveZcashAddress(pubkey, config.network);
+    // Step 1: Fetch UTXOs
+    const allUtxos = await fetchUTXOs(zebraUrl, ourAddress);
+    if (allUtxos.length === 0) {
+        throw new Error(`No UTXOs found for ${ourAddress}`);
+    }
+    // Step 2: Select UTXOs and build unsigned TX
+    const fee = estimateFee(Math.min(allUtxos.length, 3), // estimate input count
+    2 // recipient + change
+    );
+    const { selected } = selectUTXOs(allUtxos, request.amount, fee);
+    // Recompute fee with actual input count
+    const actualFee = estimateFee(selected.length, 2);
+    const { unsignedTx, sighashes, txid } = buildUnsignedTx(selected, request.to, request.amount, actualFee, ourAddress, // change back to our address
+    BRANCH_ID.NU5);
+    // Step 3: Sign each sighash via MPC
+    const signatures = [];
+    for (const sighash of sighashes) {
+        const signResult = await sign(config, {
+            messageHash: new Uint8Array(sighash),
+            walletId,
+            chain: "zcash-transparent",
+            encryptionSeed,
+        });
+        signatures.push(Buffer.from(signResult.signature));
+    }
+    // Step 4: Attach signatures
+    const txHex = attachSignatures(selected, request.to, request.amount, actualFee, ourAddress, signatures, Buffer.from(pubkey), BRANCH_ID.NU5);
+    // Step 5: Broadcast
+    const broadcastTxid = await broadcastTx(zebraUrl, txHex);
+    // Step 6: Attest to ZAP1
+    let leafHash = "";
+    if (config.zap1ApiUrl && config.zap1ApiKey) {
+        try {
+            const attestResp = await fetch(`${config.zap1ApiUrl}/attest`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${config.zap1ApiKey}`,
+                },
+                body: JSON.stringify({
+                    event_type: "AGENT_ACTION",
+                    agent_id: walletId,
+                    action: "transparent_spend",
+                    chain_txid: broadcastTxid,
+                    recipient: request.to,
+                    amount: request.amount,
+                    fee: actualFee,
+                    memo: request.memo || "",
+                }),
+            });
+            if (attestResp.ok) {
+                const attestData = (await attestResp.json());
+                leafHash = attestData.leaf_hash || "";
+            }
+        }
+        catch {
+            // Attestation failure is non-fatal - tx already broadcast
+        }
+    }
+    return {
+        txid: broadcastTxid,
+        leafHash,
+        chain: "zcash-transparent",
+        policyChecked: false, // policy enforcement via Move module is separate
+    };
 }
 /**
  * Spend from a Bitcoin wallet.

package/dist/tx-builder.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Zcash v5 transparent transaction builder with ZIP 244 sighash.
+ *
+ * Builds P2PKH transactions for MPC-signed transparent spends.
+ * The signing itself happens via Ika dWallet (secp256k1 ECDSA).
+ * This module handles everything else: UTXO fetch, TX structure,
+ * sighash computation, signature attachment, and broadcast.
+ */
+export declare const BRANCH_ID: {
+    readonly NU5: 3268858036;
+    readonly NU6: 3370586197;
+};
+export interface UTXO {
+    txid: string;
+    outputIndex: number;
+    script: string;
+    satoshis: number;
+}
+export interface TxOutput {
+    address: string;
+    amount: number;
+}
+/**
+ * Fetch UTXOs for a transparent address from Zebra RPC.
+ * Uses getaddressutxos (requires Zebra with -indexer flag).
+ */
+export declare function fetchUTXOs(zebraRpcUrl: string, tAddress: string): Promise<UTXO[]>;
+/**
+ * Select UTXOs to cover the target amount + fee.
+ * Simple largest-first selection. Returns selected UTXOs and total value.
+ */
+export declare function selectUTXOs(utxos: UTXO[], targetAmount: number, fee: number): {
+    selected: UTXO[];
+    totalInput: number;
+};
+/**
+ * Build an unsigned Zcash v5 transparent transaction.
+ *
+ * Returns the unsigned serialized TX and per-input sighashes
+ * that need to be signed via MPC.
+ */
+export declare function buildUnsignedTx(utxos: UTXO[], recipient: string, amount: number, fee: number | undefined, changeAddress: string, branchId?: number): {
+    unsignedTx: Buffer;
+    sighashes: Buffer[];
+    txid: Buffer;
+};
+/**
+ * Attach MPC signatures to an unsigned transaction.
+ *
+ * Takes the original UTXO list (to reconstruct inputs/outputs),
+ * DER-encoded signatures from MPC, and the compressed pubkey.
+ * Returns hex-encoded signed transaction ready for broadcast.
+ */
+export declare function attachSignatures(utxos: UTXO[], recipient: string, amount: number, fee: number, changeAddress: string, signatures: Buffer[], pubkey: Buffer, branchId?: number): string;
+/**
+ * Broadcast a signed transaction via Zebra RPC.
+ * Returns the txid on success.
+ */
+export declare function broadcastTx(zebraRpcUrl: string, txHex: string): Promise<string>;
+/**
+ * Estimate fee for a transparent P2PKH transaction.
+ *
+ * ZIP 317 marginal fee: max(grace_actions, logical_actions) * 5000
+ * For simple P2PKH: 1 input + 2 outputs = 2 logical actions = 10000 zatoshis
+ * Each additional input adds 1 logical action = +5000 zatoshis
+ */
+export declare function estimateFee(numInputs: number, numOutputs: number): number;

package/dist/tx-builder.js

@@ -0,0 +1,534 @@
+/**
+ * Zcash v5 transparent transaction builder with ZIP 244 sighash.
+ *
+ * Builds P2PKH transactions for MPC-signed transparent spends.
+ * The signing itself happens via Ika dWallet (secp256k1 ECDSA).
+ * This module handles everything else: UTXO fetch, TX structure,
+ * sighash computation, signature attachment, and broadcast.
+ */
+import blakejs from "blakejs";
+const { blake2bInit, blake2bUpdate, blake2bFinal } = blakejs;
+import { createHash } from "node:crypto";
+// Zcash v5 transaction constants
+const TX_VERSION = 5;
+const TX_VERSION_GROUP_ID = 0x26a7270a;
+// Consensus branch IDs
+export const BRANCH_ID = {
+    NU5: 0xc2d6d0b4,
+    NU6: 0xc8e71055,
+};
+// SIGHASH flags
+const SIGHASH_ALL = 0x01;
+// Script opcodes for P2PKH
+const OP_DUP = 0x76;
+const OP_HASH160 = 0xa9;
+const OP_EQUALVERIFY = 0x88;
+const OP_CHECKSIG = 0xac;
+// Zcash t-address version prefixes (for decoding)
+const T_ADDR_VERSIONS = {
+    "1cb8": { mainnet: true }, // t1...
+    "1d25": { mainnet: false }, // tm...
+};
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function sha256(data) {
+    return createHash("sha256").update(data).digest();
+}
+function hash160(data) {
+    return createHash("ripemd160").update(sha256(data)).digest();
+}
+// BLAKE2b-256 with personalization
+// blakejs types don't expose the personal param on blake2bInit, but the JS does
+function blake2b256(data, personal) {
+    const ctx = blake2bInit(32, undefined, undefined, personal);
+    blake2bUpdate(ctx, data);
+    return Buffer.from(blake2bFinal(ctx));
+}
+// Write uint32 little-endian into buffer
+function writeU32LE(buf, value, offset) {
+    buf.writeUInt32LE(value >>> 0, offset);
+}
+// Write int64 little-endian (as two uint32s, safe for values < 2^53)
+function writeI64LE(buf, value, offset) {
+    buf.writeUInt32LE(value & 0xffffffff, offset);
+    buf.writeUInt32LE(Math.floor(value / 0x100000000) & 0xffffffff, offset + 4);
+}
+// Compact size encoding (Bitcoin varint)
+function compactSize(n) {
+    if (n < 0xfd) {
+        return Buffer.from([n]);
+    }
+    else if (n <= 0xffff) {
+        const buf = Buffer.alloc(3);
+        buf[0] = 0xfd;
+        buf.writeUInt16LE(n, 1);
+        return buf;
+    }
+    else {
+        const buf = Buffer.alloc(5);
+        buf[0] = 0xfe;
+        buf.writeUInt32LE(n, 1);
+        return buf;
+    }
+}
+// Decode a Zcash t-address to its 20-byte pubkey hash
+function decodeTAddress(addr) {
+    // Base58 decode
+    let num = BigInt(0);
+    for (const c of addr) {
+        const idx = BASE58_ALPHABET.indexOf(c);
+        if (idx < 0)
+            throw new Error(`Invalid base58 character: ${c}`);
+        num = num * 58n + BigInt(idx);
+    }
+    // Convert to bytes (26 bytes: 2 version + 20 hash + 4 checksum)
+    const bytes = new Uint8Array(26);
+    for (let i = 25; i >= 0; i--) {
+        bytes[i] = Number(num & 0xffn);
+        num = num >> 8n;
+    }
+    // Verify checksum
+    const payload = bytes.subarray(0, 22);
+    const checksum = sha256(sha256(payload)).subarray(0, 4);
+    for (let i = 0; i < 4; i++) {
+        if (bytes[22 + i] !== checksum[i]) {
+            throw new Error(`Invalid t-address checksum: ${addr}`);
+        }
+    }
+    const versionHex = Buffer.from(bytes.subarray(0, 2)).toString("hex");
+    const info = T_ADDR_VERSIONS[versionHex];
+    if (!info) {
+        throw new Error(`Unknown t-address version: 0x${versionHex}`);
+    }
+    return {
+        pubkeyHash: Buffer.from(bytes.subarray(2, 22)),
+        mainnet: info.mainnet,
+    };
+}
+// Build a P2PKH scriptPubKey from a 20-byte pubkey hash
+function p2pkhScript(pubkeyHash) {
+    // OP_DUP OP_HASH160 <20 bytes> OP_EQUALVERIFY OP_CHECKSIG
+    const script = Buffer.alloc(25);
+    script[0] = OP_DUP;
+    script[1] = OP_HASH160;
+    script[2] = 0x14; // push 20 bytes
+    pubkeyHash.copy(script, 3);
+    script[23] = OP_EQUALVERIFY;
+    script[24] = OP_CHECKSIG;
+    return script;
+}
+// Build P2PKH scriptPubKey from a t-address string
+function scriptFromAddress(addr) {
+    const { pubkeyHash } = decodeTAddress(addr);
+    return p2pkhScript(pubkeyHash);
+}
+// Reverse a hex-encoded txid (internal byte order is reversed)
+function reverseTxid(txid) {
+    const buf = Buffer.from(txid, "hex");
+    if (buf.length !== 32)
+        throw new Error(`Invalid txid length: ${buf.length}`);
+    return Buffer.from(buf.reverse());
+}
+// Consensus branch ID as 4-byte LE buffer
+function branchIdBytes(branchId) {
+    const buf = Buffer.alloc(4);
+    writeU32LE(buf, branchId, 0);
+    return buf;
+}
+// ZIP 244 sighash computation for v5 transparent transactions
+// Personalization string as bytes, padded/truncated to 16 bytes
+function personalization(tag, suffix) {
+    const tagBytes = Buffer.from(tag, "ascii");
+    if (suffix) {
+        const result = Buffer.alloc(16);
+        tagBytes.copy(result, 0, 0, Math.min(tagBytes.length, 12));
+        suffix.copy(result, 12, 0, 4);
+        return result;
+    }
+    // Pad to 16 bytes with zeros
+    const result = Buffer.alloc(16);
+    tagBytes.copy(result, 0, 0, Math.min(tagBytes.length, 16));
+    return result;
+}
+// Hash of all prevouts (txid + index) for transparent inputs
+function hashPrevouts(inputs, branchId) {
+    const parts = [];
+    for (const inp of inputs) {
+        const outpoint = Buffer.alloc(36);
+        inp.prevTxid.copy(outpoint, 0);
+        writeU32LE(outpoint, inp.prevIndex, 32);
+        parts.push(outpoint);
+    }
+    const data = Buffer.concat(parts);
+    return blake2b256(data, personalization("ZTxIdPrevoutHash", branchIdBytes(branchId)));
+}
+// Hash of all input amounts
+function hashAmounts(inputs, branchId) {
+    const data = Buffer.alloc(inputs.length * 8);
+    for (let i = 0; i < inputs.length; i++) {
+        writeI64LE(data, inputs[i].value, i * 8);
+    }
+    return blake2b256(data, personalization("ZTxTrAmountsHash", branchIdBytes(branchId)));
+}
+// Hash of all input scriptPubKeys
+function hashScriptPubKeys(inputs, branchId) {
+    const parts = [];
+    for (const inp of inputs) {
+        parts.push(compactSize(inp.script.length));
+        parts.push(inp.script);
+    }
+    const data = Buffer.concat(parts);
+    return blake2b256(data, personalization("ZTxTrScriptsHash", branchIdBytes(branchId)));
+}
+// Hash of all sequences
+function hashSequences(inputs, branchId) {
+    const data = Buffer.alloc(inputs.length * 4);
+    for (let i = 0; i < inputs.length; i++) {
+        writeU32LE(data, inputs[i].sequence, i * 4);
+    }
+    return blake2b256(data, personalization("ZTxIdSequencHash", branchIdBytes(branchId)));
+}
+// Hash of all transparent outputs
+function hashOutputs(outputs, branchId) {
+    const parts = [];
+    for (const out of outputs) {
+        const valueBuf = Buffer.alloc(8);
+        writeI64LE(valueBuf, out.value, 0);
+        parts.push(valueBuf);
+        parts.push(compactSize(out.script.length));
+        parts.push(out.script);
+    }
+    const data = Buffer.concat(parts);
+    return blake2b256(data, personalization("ZTxIdOutputsHash", branchIdBytes(branchId)));
+}
+// Transparent inputs digest (ZIP 244 section T.3a)
+function transparentInputsDigest(inputs, branchId) {
+    const prevoutsHash = hashPrevouts(inputs, branchId);
+    const amountsHash = hashAmounts(inputs, branchId);
+    const scriptPubKeysHash = hashScriptPubKeys(inputs, branchId);
+    const sequencesHash = hashSequences(inputs, branchId);
+    const data = Buffer.concat([prevoutsHash, amountsHash, scriptPubKeysHash, sequencesHash]);
+    return blake2b256(data, personalization("ZTxIdTrInHash__", branchIdBytes(branchId)));
+}
+// Transparent outputs digest (ZIP 244 section T.3b)
+function transparentOutputsDigest(outputs, branchId) {
+    const outputsHash = hashOutputs(outputs, branchId);
+    return blake2b256(outputsHash, personalization("ZTxIdTrOutHash_", branchIdBytes(branchId)));
+}
+// Full transparent digest for txid (ZIP 244 T.3)
+function transparentDigest(inputs, outputs, branchId) {
+    if (inputs.length === 0 && outputs.length === 0) {
+        return blake2b256(Buffer.alloc(0), personalization("ZTxIdTranspaHash", branchIdBytes(branchId)));
+    }
+    const inDigest = transparentInputsDigest(inputs, branchId);
+    const outDigest = transparentOutputsDigest(outputs, branchId);
+    return blake2b256(Buffer.concat([inDigest, outDigest]), personalization("ZTxIdTranspaHash", branchIdBytes(branchId)));
+}
+// Sapling digest (empty bundle)
+function emptyBundleDigest(tag, branchId) {
+    return blake2b256(Buffer.alloc(0), personalization(tag, branchIdBytes(branchId)));
+}
+// Header digest (ZIP 244 T.1)
+function headerDigest(version, versionGroupId, branchId, lockTime, expiryHeight) {
+    const data = Buffer.alloc(4 + 4 + 4 + 4 + 4);
+    writeU32LE(data, version, 0);
+    writeU32LE(data, versionGroupId, 4);
+    writeU32LE(data, branchId, 8);
+    writeU32LE(data, lockTime, 12);
+    writeU32LE(data, expiryHeight, 16);
+    return blake2b256(data, personalization("ZTxIdHeadersHash", branchIdBytes(branchId)));
+}
+// Transaction digest for txid (ZIP 244 T)
+function txidDigest(inputs, outputs, branchId, lockTime, expiryHeight) {
+    const hdrDigest = headerDigest(TX_VERSION, TX_VERSION_GROUP_ID, branchId, lockTime, expiryHeight);
+    const txpDigest = transparentDigest(inputs, outputs, branchId);
+    const sapDigest = emptyBundleDigest("ZTxIdSaplingHash", branchId);
+    const orchDigest = emptyBundleDigest("ZTxIdOrchardHash", branchId);
+    return blake2b256(Buffer.concat([hdrDigest, txpDigest, sapDigest, orchDigest]), personalization("ZcashTxHash__", branchIdBytes(branchId)));
+}
+// Per-input sighash for signing (ZIP 244 S.2 - transparent)
+// This is the hash that actually gets signed by ECDSA
+function transparentSighash(inputs, outputs, branchId, lockTime, expiryHeight, inputIndex, hashType) {
+    // T.1: header digest
+    const hdrDigest = headerDigest(TX_VERSION, TX_VERSION_GROUP_ID, branchId, lockTime, expiryHeight);
+    // T.3: transparent digest (full, for the txid computation)
+    const txpDigest = transparentDigest(inputs, outputs, branchId);
+    // T.4: sapling digest (empty)
+    const sapDigest = emptyBundleDigest("ZTxIdSaplingHash", branchId);
+    // T.5: orchard digest (empty)
+    const orchDigest = emptyBundleDigest("ZTxIdOrchardHash", branchId);
+    // S.2: per-input transparent sighash data
+    // hash_type (1 byte)
+    // prevout (32 + 4 bytes)
+    // value (8 bytes)
+    // scriptPubKey (compact size + script bytes)
+    // sequence (4 bytes)
+    const inp = inputs[inputIndex];
+    const prevout = Buffer.alloc(36);
+    inp.prevTxid.copy(prevout, 0);
+    writeU32LE(prevout, inp.prevIndex, 32);
+    const valueBuf = Buffer.alloc(8);
+    writeI64LE(valueBuf, inp.value, 0);
+    const seqBuf = Buffer.alloc(4);
+    writeU32LE(seqBuf, inp.sequence, 0);
+    const txinSigDigestData = Buffer.concat([
+        Buffer.from([hashType]),
+        prevout,
+        valueBuf,
+        compactSize(inp.script.length),
+        inp.script,
+        seqBuf,
+    ]);
+    const txinSigDigest = blake2b256(txinSigDigestData, personalization("Zcash___TxInHash", branchIdBytes(branchId)));
+    // Final sighash: BLAKE2b of all digests
+    return blake2b256(Buffer.concat([hdrDigest, txpDigest, sapDigest, orchDigest, txinSigDigest]), personalization("ZcashTxHash__", branchIdBytes(branchId)));
+}
+// Serialize a v5 transparent-only transaction to raw bytes.
+// If scriptSigs is provided, inputs get signed scriptSigs.
+// Otherwise inputs get empty scriptSigs (unsigned).
+function serializeTx(inputs, outputs, branchId, lockTime, expiryHeight, scriptSigs) {
+    const parts = [];
+    // Header
+    const header = Buffer.alloc(4);
+    // v5: version field encodes (version | fOverwintered flag)
+    // fOverwintered = 1 << 31
+    writeU32LE(header, (TX_VERSION | (1 << 31)) >>> 0, 0);
+    parts.push(header);
+    // nVersionGroupId
+    const vgid = Buffer.alloc(4);
+    writeU32LE(vgid, TX_VERSION_GROUP_ID, 0);
+    parts.push(vgid);
+    // nConsensusBranchId
+    parts.push(branchIdBytes(branchId));
+    // nLockTime
+    const lt = Buffer.alloc(4);
+    writeU32LE(lt, lockTime, 0);
+    parts.push(lt);
+    // nExpiryHeight
+    const eh = Buffer.alloc(4);
+    writeU32LE(eh, expiryHeight, 0);
+    parts.push(eh);
+    // Transparent bundle
+    // tx_in_count
+    parts.push(compactSize(inputs.length));
+    // tx_in
+    for (let i = 0; i < inputs.length; i++) {
+        const inp = inputs[i];
+        // prevout
+        const outpoint = Buffer.alloc(36);
+        inp.prevTxid.copy(outpoint, 0);
+        writeU32LE(outpoint, inp.prevIndex, 32);
+        parts.push(outpoint);
+        // scriptSig
+        const sig = scriptSigs ? scriptSigs[i] : Buffer.alloc(0);
+        parts.push(compactSize(sig.length));
+        if (sig.length > 0)
+            parts.push(sig);
+        // sequence
+        const seq = Buffer.alloc(4);
+        writeU32LE(seq, inp.sequence, 0);
+        parts.push(seq);
+    }
+    // tx_out_count
+    parts.push(compactSize(outputs.length));
+    // tx_out
+    for (const out of outputs) {
+        const valueBuf = Buffer.alloc(8);
+        writeI64LE(valueBuf, out.value, 0);
+        parts.push(valueBuf);
+        parts.push(compactSize(out.script.length));
+        parts.push(out.script);
+    }
+    // Sapling bundle (empty)
+    parts.push(compactSize(0)); // nSpendsSapling
+    parts.push(compactSize(0)); // nOutputsSapling
+    // Orchard bundle (empty)
+    parts.push(Buffer.from([0x00])); // nActionsOrchard = 0
+    return Buffer.concat(parts);
+}
+/**
+ * Fetch UTXOs for a transparent address from Zebra RPC.
+ * Uses getaddressutxos (requires Zebra with -indexer flag).
+ */
+export async function fetchUTXOs(zebraRpcUrl, tAddress) {
+    const resp = await fetch(zebraRpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "getaddressutxos",
+            params: [{ addresses: [tAddress] }],
+        }),
+    });
+    if (!resp.ok) {
+        throw new Error(`Zebra RPC error: ${resp.status} ${resp.statusText}`);
+    }
+    const data = (await resp.json());
+    if (data.error) {
+        throw new Error(`Zebra RPC: ${data.error.message || JSON.stringify(data.error)}`);
+    }
+    const utxos = (data.result || []).map((u) => ({
+        txid: u.txid,
+        outputIndex: u.outputIndex ?? u.vout ?? u.index,
+        script: u.script ?? u.scriptPubKey,
+        satoshis: u.satoshis ?? u.value ?? u.amount,
+    }));
+    return utxos;
+}
+/**
+ * Select UTXOs to cover the target amount + fee.
+ * Simple largest-first selection. Returns selected UTXOs and total value.
+ */
+export function selectUTXOs(utxos, targetAmount, fee) {
+    const needed = targetAmount + fee;
+    // Sort descending by value
+    const sorted = [...utxos].sort((a, b) => b.satoshis - a.satoshis);
+    const selected = [];
+    let total = 0;
+    for (const u of sorted) {
+        selected.push(u);
+        total += u.satoshis;
+        if (total >= needed)
+            break;
+    }
+    if (total < needed) {
+        throw new Error(`Insufficient funds: have ${total} zatoshis, need ${needed} (${targetAmount} + ${fee} fee)`);
+    }
+    return { selected, totalInput: total };
+}
+/**
+ * Build an unsigned Zcash v5 transparent transaction.
+ *
+ * Returns the unsigned serialized TX and per-input sighashes
+ * that need to be signed via MPC.
+ */
+export function buildUnsignedTx(utxos, recipient, amount, fee = 10000, changeAddress, branchId = BRANCH_ID.NU5) {
+    if (utxos.length === 0)
+        throw new Error("No UTXOs provided");
+    if (amount <= 0)
+        throw new Error("Amount must be positive");
+    // Build inputs
+    const inputs = utxos.map((u) => ({
+        prevTxid: reverseTxid(u.txid),
+        prevIndex: u.outputIndex,
+        script: Buffer.from(u.script, "hex"),
+        value: u.satoshis,
+        sequence: 0xffffffff,
+    }));
+    // Build outputs
+    const totalInput = utxos.reduce((s, u) => s + u.satoshis, 0);
+    const change = totalInput - amount - fee;
+    const outputs = [
+        { value: amount, script: scriptFromAddress(recipient) },
+    ];
+    if (change > 0) {
+        // Dust threshold: skip change if below 546 zatoshis
+        if (change >= 546) {
+            outputs.push({ value: change, script: scriptFromAddress(changeAddress) });
+        }
+    }
+    else if (change < 0) {
+        throw new Error(`UTXOs total ${totalInput} < amount ${amount} + fee ${fee}`);
+    }
+    const lockTime = 0;
+    const expiryHeight = 0;
+    // Serialize unsigned TX
+    const unsignedTx = serializeTx(inputs, outputs, branchId, lockTime, expiryHeight);
+    // Compute per-input sighashes
+    const sighashes = [];
+    for (let i = 0; i < inputs.length; i++) {
+        const sh = transparentSighash(inputs, outputs, branchId, lockTime, expiryHeight, i, SIGHASH_ALL);
+        sighashes.push(sh);
+    }
+    // Compute txid (hash of unsigned TX structure per ZIP 244)
+    const txid = txidDigest(inputs, outputs, branchId, lockTime, expiryHeight);
+    return { unsignedTx, sighashes, txid };
+}
+/**
+ * Build a P2PKH scriptSig from a DER signature and compressed pubkey.
+ *
+ * Format: <sig_length> <DER_sig + SIGHASH_ALL_byte> <pubkey_length> <compressed_pubkey>
+ */
+function buildScriptSig(derSig, pubkey) {
+    // Append SIGHASH_ALL byte to signature
+    const sigWithHashType = Buffer.concat([derSig, Buffer.from([SIGHASH_ALL])]);
+    const parts = [
+        Buffer.from([sigWithHashType.length]),
+        sigWithHashType,
+        Buffer.from([pubkey.length]),
+        pubkey,
+    ];
+    return Buffer.concat(parts);
+}
+/**
+ * Attach MPC signatures to an unsigned transaction.
+ *
+ * Takes the original UTXO list (to reconstruct inputs/outputs),
+ * DER-encoded signatures from MPC, and the compressed pubkey.
+ * Returns hex-encoded signed transaction ready for broadcast.
+ */
+export function attachSignatures(utxos, recipient, amount, fee, changeAddress, signatures, pubkey, branchId = BRANCH_ID.NU5) {
+    if (signatures.length !== utxos.length) {
+        throw new Error(`Expected ${utxos.length} signatures, got ${signatures.length}`);
+    }
+    if (pubkey.length !== 33) {
+        throw new Error(`Expected 33-byte compressed pubkey, got ${pubkey.length}`);
+    }
+    // Rebuild inputs/outputs (same as buildUnsignedTx)
+    const inputs = utxos.map((u) => ({
+        prevTxid: reverseTxid(u.txid),
+        prevIndex: u.outputIndex,
+        script: Buffer.from(u.script, "hex"),
+        value: u.satoshis,
+        sequence: 0xffffffff,
+    }));
+    const totalInput = utxos.reduce((s, u) => s + u.satoshis, 0);
+    const change = totalInput - amount - fee;
+    const outputs = [
+        { value: amount, script: scriptFromAddress(recipient) },
+    ];
+    if (change >= 546) {
+        outputs.push({ value: change, script: scriptFromAddress(changeAddress) });
+    }
+    // Build scriptSigs
+    const scriptSigs = signatures.map((sig) => buildScriptSig(sig, pubkey));
+    // Serialize signed TX
+    const signedTx = serializeTx(inputs, outputs, branchId, 0, 0, scriptSigs);
+    return signedTx.toString("hex");
+}
+/**
+ * Broadcast a signed transaction via Zebra RPC.
+ * Returns the txid on success.
+ */
+export async function broadcastTx(zebraRpcUrl, txHex) {
+    const resp = await fetch(zebraRpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "sendrawtransaction",
+            params: [txHex],
+        }),
+    });
+    if (!resp.ok) {
+        throw new Error(`Zebra RPC error: ${resp.status} ${resp.statusText}`);
+    }
+    const data = (await resp.json());
+    if (data.error) {
+        throw new Error(`Broadcast failed: ${data.error.message || JSON.stringify(data.error)}`);
+    }
+    return data.result;
+}
+/**
+ * Estimate fee for a transparent P2PKH transaction.
+ *
+ * ZIP 317 marginal fee: max(grace_actions, logical_actions) * 5000
+ * For simple P2PKH: 1 input + 2 outputs = 2 logical actions = 10000 zatoshis
+ * Each additional input adds 1 logical action = +5000 zatoshis
+ */
+export function estimateFee(numInputs, numOutputs) {
+    const logicalActions = Math.max(numInputs, numOutputs);
+    const graceActions = 2;
+    return Math.max(graceActions, logicalActions) * 5000;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@frontiercompute/zcash-ika",
-  "version": "0.2.0",
-  "description": "Split-key Zcash custody via Ika dWallet. secp256k1 MPC for transparent, hybrid model for shielded.",
+  "version": "0.3.0",
+  "description": "Split-key custody for Zcash, Bitcoin, and EVM. 2PC-MPC signing, on-chain spend policy, transparent TX builder, ZAP1 attestation.",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {
@@ -11,18 +11,38 @@
   },
   "dependencies": {
     "@ika.xyz/sdk": "^0.3.1",
-    "@mysten/sui": "^2.5.0"
+    "@mysten/sui": "^2.5.0",
+    "blakejs": "^1.2.1"
   },
   "devDependencies": {
     "@types/node": "^25.5.2",
     "typescript": "^5.4.0"
   },
-  "files": ["dist/index.js", "dist/index.d.ts", "dist/hybrid.js", "dist/hybrid.d.ts"],
+  "files": [
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/tx-builder.js",
+    "dist/tx-builder.d.ts",
+    "dist/hybrid.js",
+    "dist/hybrid.d.ts"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/Frontier-Compute/zcash-ika.git"
   },
   "author": "zk_nd3r <zk_nd3r@frontiercompute.io>",
-  "keywords": ["zcash", "ika", "dwallet", "mpc", "custody", "bitcoin", "split-key"],
+  "keywords": [
+    "zcash",
+    "ika",
+    "dwallet",
+    "mpc",
+    "custody",
+    "bitcoin",
+    "split-key",
+    "policy",
+    "sui-move",
+    "transparent-tx",
+    "attestation"
+  ],
   "license": "MIT"
 }