@swapkit/toolboxes 1.0.0-beta.3 → 1.0.0-beta.31

package/src/utxo/helpers/bchaddrjs.ts

@@ -1,5 +1,6 @@
+import { SwapKitError } from "@swapkit/helpers";
 import base58check from "bs58check";
-// @ts-expect-error
+// @ts-ignore
 import cashaddr from "cashaddrjs";
 
 enum Format {
@@ -83,7 +84,7 @@ function decodeAddress(address: string) {
   } catch (_error) {
     // Try to decode as bitpay if cashaddr decoding fails.
   }
-  throw new Error("Received an invalid Bitcoin Cash address as input.");
+  throw new SwapKitError("toolbox_utxo_invalid_address", { address });
 }
 
 function decodeBase58Address(address: string) {
@@ -91,8 +92,7 @@ function decodeBase58Address(address: string) {
     const payload = base58check.decode(address);
 
     // BASE_58_CHECK_PAYLOAD_LENGTH
-    if (payload.length !== 21)
-      throw new Error("Received an invalid Bitcoin Cash address as input.");
+    if (payload.length !== 21) throw new SwapKitError("toolbox_utxo_invalid_address", { address });
     const versionByte = payload[0];
     const hash = Array.prototype.slice.call(payload, 1);
 
@@ -116,10 +116,10 @@ function decodeBase58Address(address: string) {
         return { hash, format: Format.Bitpay, network: UtxoNetwork.Mainnet, type: Type.P2SH };
 
       default:
-        throw new Error("Received an invalid Bitcoin Cash address as input.");
+        throw new SwapKitError("toolbox_utxo_invalid_address", { address });
     }
   } catch (_error) {
-    throw new Error("Received an invalid Bitcoin Cash address as input.");
+    throw new SwapKitError("toolbox_utxo_invalid_address", { address });
   }
 }
 
@@ -141,7 +141,7 @@ function decodeCashAddress(address: string) {
     }
   }
 
-  throw new Error("Received an invalid Bitcoin Cash address as input.");
+  throw new SwapKitError("toolbox_utxo_invalid_address", { address });
 }
 
 function decodeCashAddressWithPrefix(address: string): DecodedType {
@@ -155,7 +155,7 @@ function decodeCashAddressWithPrefix(address: string): DecodedType {
       type: type === "P2PKH" ? Type.P2PKH : Type.P2SH,
     };
   } catch (_error) {
-    throw new Error("Received an invalid Bitcoin Cash address as input.");
+    throw new SwapKitError("toolbox_utxo_invalid_address", { address });
   }
 }
 

package/src/utxo/helpers/coinselect.ts

@@ -1,4 +1,4 @@
-import { Chain, type UTXOChain } from "@swapkit/helpers";
+import { Chain, SwapKitError, type UTXOChain } from "@swapkit/helpers";
 
 import {
   TX_OVERHEAD,
@@ -20,8 +20,10 @@ export const getDustThreshold = (chain: UTXOChain) => {
       return 5500;
     case Chain.Dogecoin:
       return 100000;
+    case Chain.Zcash:
+      return 546;
     default:
-      throw new Error("Invalid Chain");
+      throw new SwapKitError("toolbox_utxo_not_supported", { chain });
   }
 };
 

package/src/utxo/helpers/txSize.ts

@@ -1,3 +1,5 @@
+import { SwapKitError } from "@swapkit/helpers";
+import { opcodes, script } from "bitcoinjs-lib";
 import type {
   TargetOutput,
   UTXOCalculateTxSizeParams,
@@ -16,8 +18,7 @@ export const OP_RETURN_OVERHEAD = 1 + 8 + 1; //10
 const TX_INPUT_BASE = 32 + 4 + 1 + 4; // 41
 const TX_INPUT_PUBKEYHASH = 107;
 
-export async function compileMemo(memo: string) {
-  const { script, opcodes } = await import("bitcoinjs-lib");
+export function compileMemo(memo: string) {
   const data = Buffer.from(memo, "utf8"); // converts MEMO to buffer
   return script.compile([opcodes.OP_RETURN as number, data]); // Compile OP_RETURN script
 }
@@ -60,7 +61,7 @@ export const getScriptTypeForAddress = (address: string) => {
   ) {
     return UTXOScriptType.P2PKH;
   }
-  throw new Error("Invalid address");
+  throw new SwapKitError("toolbox_utxo_invalid_address", { address });
 };
 
 export const calculateTxSize = ({ inputs, outputs, feeRate }: UTXOCalculateTxSizeParams) => {

package/src/utxo/index.ts

@@ -1,5 +1,6 @@
 export * from "./toolbox";
 export * from "./toolbox/bitcoinCash";
 export * from "./toolbox/utxo";
+export * from "./toolbox/zcash";
 export * from "./helpers";
 export * from "./types";

package/src/utxo/toolbox/bitcoinCash.ts

@@ -1,12 +1,20 @@
+import {
+  Transaction,
+  TransactionBuilder,
+  address as bchAddress,
+  // @ts-ignore
+} from "@psf/bitcoincashjs-lib";
 import {
   Chain,
   type ChainSigner,
   type DerivationPathArray,
   FeeOption,
   NetworkDerivationPath,
+  SwapKitError,
   derivationPathToString,
   updateDerivationPath,
 } from "@swapkit/helpers";
+import { Psbt } from "bitcoinjs-lib";
 import type { UtxoToolboxParams } from ".";
 import {
   accumulative,
@@ -130,13 +138,8 @@ async function createTransaction({
   feeRate,
   sender,
 }: UTXOBuildTxParams) {
-  const {
-    Transaction,
-    TransactionBuilder,
-    address: bchAddress,
-    // @ts-ignore
-  } = await import("@psf/bitcoincashjs-lib");
-  if (!bchValidateAddress(recipient)) throw new Error("Invalid address");
+  if (!bchValidateAddress(recipient))
+    throw new SwapKitError("toolbox_utxo_invalid_address", { address: recipient });
   const utxos = await getUtxoApi(chain).scanUTXOs({
     address: stripToCashAddress(sender),
     fetchTxHex: true,
@@ -158,9 +161,10 @@ async function createTransaction({
   });
 
   // .inputs and .outputs will be undefined if no solution was found
-  if (!(inputs && outputs)) throw new Error("Balance insufficient for transaction");
+  if (!(inputs && outputs))
+    throw new SwapKitError("toolbox_utxo_insufficient_balance", { sender, assetValue });
   const getNetwork = await getUtxoNetwork();
-  const builder = new TransactionBuilder(getNetwork(chain));
+  const builder = new TransactionBuilder(getNetwork(chain)) as TransactionBuilderType;
 
   await Promise.all(
     inputs.map(async (utxo: UTXOType) => {
@@ -203,8 +207,11 @@ function transfer({
     ...rest
   }: UTXOTransferParams) {
     const from = await signer?.getAddress();
-    if (!(signer && from)) throw new Error("Signer must provider address");
-    if (!recipient) throw new Error("Recipient address must be provided");
+    if (!(signer && from)) throw new SwapKitError("toolbox_utxo_no_signer");
+    if (!recipient)
+      throw new SwapKitError("toolbox_utxo_invalid_params", {
+        error: "Recipient address must be provided",
+      });
 
     const feeRate = rest.feeRate || (await getFeeRates())[feeOptionKey];
 
@@ -226,9 +233,9 @@ function transfer({
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
 async function buildTx({ assetValue, recipient, memo, feeRate, sender }: UTXOBuildTxParams) {
-  const { Psbt } = await import("bitcoinjs-lib");
   const recipientCashAddress = toCashAddress(recipient);
-  if (!bchValidateAddress(recipientCashAddress)) throw new Error("Invalid address");
+  if (!bchValidateAddress(recipientCashAddress))
+    throw new SwapKitError("toolbox_utxo_invalid_address", { address: recipientCashAddress });
 
   const utxos = await getUtxoApi(chain).scanUTXOs({
     address: stripToCashAddress(sender),
@@ -259,7 +266,8 @@ async function buildTx({ assetValue, recipient, memo, feeRate, sender }: UTXOBui
   });
 
   // .inputs and .outputs will be undefined if no solution was found
-  if (!(inputs && outputs)) throw new Error("Balance insufficient for transaction");
+  if (!(inputs && outputs))
+    throw new SwapKitError("toolbox_utxo_insufficient_balance", { sender, assetValue });
   const getNetwork = await getUtxoNetwork();
   const psbt = new Psbt({ network: getNetwork(chain) }); // Network-specific
 

package/src/utxo/toolbox/index.ts

@@ -2,6 +2,7 @@ import {
   Chain,
   type ChainSigner,
   type DerivationPathArray,
+  SwapKitError,
   type UTXOChain,
 } from "@swapkit/helpers";
 import type { Psbt } from "bitcoinjs-lib";
@@ -9,11 +10,13 @@ import type { Psbt } from "bitcoinjs-lib";
 import type { TransactionBuilderType, TransactionType, UTXOType } from "../types";
 import { createBCHToolbox } from "./bitcoinCash";
 import { createUTXOToolbox } from "./utxo";
+import { createZcashToolbox } from "./zcash";
 
 type BCHToolbox = Awaited<ReturnType<typeof createBCHToolbox>>;
 type CommonUTXOToolbox = Awaited<
-  ReturnType<typeof createUTXOToolbox<Exclude<UTXOChain, Chain.BitcoinCash>>>
+  ReturnType<typeof createUTXOToolbox<Exclude<UTXOChain, Chain.BitcoinCash | Chain.Zcash>>>
 >;
+type ZcashToolbox = Awaited<ReturnType<typeof createZcashToolbox>>;
 
 export type UTXOToolboxes = {
   [Chain.BitcoinCash]: BCHToolbox;
@@ -21,6 +24,7 @@ export type UTXOToolboxes = {
   [Chain.Dogecoin]: CommonUTXOToolbox;
   [Chain.Litecoin]: CommonUTXOToolbox;
   [Chain.Dash]: CommonUTXOToolbox;
+  [Chain.Zcash]: ZcashToolbox;
 };
 
 export type UTXOWallets = {
@@ -35,6 +39,9 @@ export type UtxoToolboxParams = {
   [Chain.Dogecoin]: { signer: ChainSigner<Psbt, Psbt> };
   [Chain.Litecoin]: { signer: ChainSigner<Psbt, Psbt> };
   [Chain.Dash]: { signer: ChainSigner<Psbt, Psbt> };
+  [Chain.Zcash]: {
+    signer?: ChainSigner<Psbt, Psbt>;
+  };
 };
 
 export async function getUtxoToolbox<T extends keyof UTXOToolboxes>(
@@ -53,19 +60,24 @@ export async function getUtxoToolbox<T extends keyof UTXOToolboxes>(
       return toolbox as UTXOToolboxes[T];
     }
 
+    case Chain.Zcash: {
+      const toolbox = await createZcashToolbox(params as UtxoToolboxParams[Chain.Zcash]);
+      return toolbox as UTXOToolboxes[T];
+    }
+
     case Chain.Bitcoin:
     case Chain.Dogecoin:
     case Chain.Litecoin:
     case Chain.Dash: {
       const toolbox = await createUTXOToolbox({
         chain,
-        ...(params as UtxoToolboxParams[Exclude<T, Chain.BitcoinCash>]),
+        ...(params as UtxoToolboxParams[Exclude<T, Chain.BitcoinCash | Chain.Zcash>]),
       });
-      return toolbox as UTXOToolboxes[Exclude<T, Chain.BitcoinCash>];
+      return toolbox as UTXOToolboxes[Exclude<T, Chain.BitcoinCash | Chain.Zcash>];
     }
 
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_utxo_not_supported", { chain });
   }
 }
 

package/src/utxo/toolbox/utxo.ts

@@ -6,13 +6,16 @@ import {
   type DerivationPathArray,
   FeeOption,
   NetworkDerivationPath,
+  SwapKitError,
   SwapKitNumber,
   type UTXOChain,
+  applyFeeMultiplier,
   derivationPathToString,
   updateDerivationPath,
 } from "@swapkit/helpers";
-import type { Psbt } from "bitcoinjs-lib";
+import { Psbt, address as btcLibAddress, initEccLib, payments } from "bitcoinjs-lib";
 import type { ECPairInterface } from "ecpair";
+import ECPairFactory from "ecpair";
 import type { UtxoToolboxParams } from ".";
 import { getBalance } from "../../utils";
 import {
@@ -34,9 +37,16 @@ import type {
 } from "../types";
 import { bchValidateAddress } from "./bitcoinCash";
 
+import secp256k1 from "@bitcoinerlab/secp256k1";
+// @ts-ignore
+import { ECPair, HDNode } from "@psf/bitcoincashjs-lib";
+import { HDKey } from "@scure/bip32";
+import { mnemonicToSeedSync } from "@scure/bip39";
+import { validateZcashAddress } from "./zcash";
+
 export const nonSegwitChains = [Chain.Dash, Chain.Dogecoin];
 
-async function addInputsAndOutputs({
+function addInputsAndOutputs({
   inputs,
   outputs,
   chain,
@@ -62,9 +72,6 @@ async function addInputsAndOutputs({
     psbt.addInput({ hash: utxo.hash, index: utxo.index, ...witnessInfo, ...nonWitnessInfo });
   }
 
-  const { initEccLib } = await import("bitcoinjs-lib");
-  const secp256k1 = await import("@bitcoinerlab/secp256k1");
-
   for (const output of outputs) {
     const address = "address" in output && output.address ? output.address : sender;
     const hasOutputScript = output.script;
@@ -103,8 +110,6 @@ async function createTransaction({
   inputs: UTXOType[];
 }> {
   const chain = assetValue.chain as UTXOChain;
-
-  const { Psbt } = await import("bitcoinjs-lib");
   const compiledMemo = memo ? await compileMemo(memo) : null;
 
   const inputsAndOutputs = await getInputsAndTargetOutputs({
@@ -118,7 +123,8 @@ async function createTransaction({
   const { inputs, outputs } = accumulative({ ...inputsAndOutputs, feeRate, chain });
 
   // .inputs and .outputs will be undefined if no solution was found
-  if (!(inputs && outputs)) throw new Error("Insufficient Balance for transaction");
+  if (!(inputs && outputs))
+    throw new SwapKitError("toolbox_utxo_insufficient_balance", { sender, assetValue });
   const getNetwork = await getUtxoNetwork();
   const psbt = new Psbt({ network: getNetwork(chain) });
 
@@ -141,8 +147,6 @@ async function createTransaction({
 }
 
 export async function getUTXOAddressValidator() {
-  const secp256k1 = await import("@bitcoinerlab/secp256k1");
-  const { initEccLib, address: btcLibAddress } = await import("bitcoinjs-lib");
   const getNetwork = await getUtxoNetwork();
 
   return function validateAddress({ address, chain }: { address: string; chain: UTXOChain }) {
@@ -150,6 +154,10 @@ export async function getUTXOAddressValidator() {
       return bchValidateAddress(address);
     }
 
+    if (chain === Chain.Zcash) {
+      return validateZcashAddress(address);
+    }
+
     try {
       initEccLib(secp256k1);
       btcLibAddress.toOutputScript(address, getNetwork(chain));
@@ -348,6 +356,7 @@ type CreateKeysForPathReturnType = {
   [Chain.Dash]: ECPairInterface;
   [Chain.Dogecoin]: ECPairInterface;
   [Chain.Litecoin]: ECPairInterface;
+  [Chain.Zcash]: ECPairInterface;
 };
 
 export async function getCreateKeysForPath<T extends keyof CreateKeysForPathReturnType>(
@@ -359,13 +368,7 @@ export async function getCreateKeysForPath<T extends keyof CreateKeysForPathRetu
     derivationPath?: string;
   }) => CreateKeysForPathReturnType[T]
 > {
-  const { ECPairFactory } = await import("ecpair");
-  const secp256k1 = await import("@bitcoinerlab/secp256k1");
-  const { HDKey } = await import("@scure/bip32");
-  const { mnemonicToSeedSync } = await import("@scure/bip39");
   const getNetwork = await getUtxoNetwork();
-  // @ts-ignore
-  const { HDNode, ECPair } = await import("@psf/bitcoincashjs-lib");
 
   switch (chain) {
     case Chain.BitcoinCash: {
@@ -379,7 +382,8 @@ export async function getCreateKeysForPath<T extends keyof CreateKeysForPathRetu
         if (wif) {
           return ECPair.fromWIF(wif, network) as BchECPair;
         }
-        if (!phrase) throw new Error("No phrase provided");
+        if (!phrase)
+          throw new SwapKitError("toolbox_utxo_invalid_params", { error: "No phrase provided" });
 
         const masterHDNode = HDNode.fromSeedBuffer(
           Buffer.from(mnemonicToSeedSync(phrase)),
@@ -397,13 +401,17 @@ export async function getCreateKeysForPath<T extends keyof CreateKeysForPathRetu
     case Chain.Bitcoin:
     case Chain.Dogecoin:
     case Chain.Litecoin:
+    case Chain.Zcash:
     case Chain.Dash: {
       return function createKeysForPath({
         phrase,
         wif,
         derivationPath,
       }: { phrase?: string; wif?: string; derivationPath: string }) {
-        if (!(wif || phrase)) throw new Error("Either phrase or wif must be provided");
+        if (!(wif || phrase))
+          throw new SwapKitError("toolbox_utxo_invalid_params", {
+            error: "Either phrase or wif must be provided",
+          });
 
         const factory = ECPairFactory(secp256k1);
         const network = getNetwork(chain);
@@ -412,7 +420,10 @@ export async function getCreateKeysForPath<T extends keyof CreateKeysForPathRetu
 
         const seed = mnemonicToSeedSync(phrase as string);
         const master = HDKey.fromMasterSeed(seed, network).derive(derivationPath);
-        if (!master.privateKey) throw new Error("Could not get private key from phrase");
+        if (!master.privateKey)
+          throw new SwapKitError("toolbox_utxo_invalid_params", {
+            error: "Could not get private key from phrase",
+          });
 
         return factory.fromPrivateKey(Buffer.from(master.privateKey), { network });
       } as (params: {
@@ -422,20 +433,21 @@ export async function getCreateKeysForPath<T extends keyof CreateKeysForPathRetu
       }) => CreateKeysForPathReturnType[T];
     }
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_utxo_not_supported", { chain });
   }
 }
 
 export async function addressFromKeysGetter(chain: UTXOChain) {
-  const { payments } = await import("bitcoinjs-lib");
   const getNetwork = await getUtxoNetwork();
 
   return function getAddressFromKeys(keys: ECPairInterface | BchECPair) {
-    if (!keys) throw new Error("Keys must be provided");
+    if (!keys)
+      throw new SwapKitError("toolbox_utxo_invalid_params", { error: "Keys must be provided" });
 
     const method = nonSegwitChains.includes(chain) ? payments.p2pkh : payments.p2wpkh;
     const { address } = method({ pubkey: keys.publicKey as Buffer, network: getNetwork(chain) });
-    if (!address) throw new Error("Address not defined");
+    if (!address)
+      throw new SwapKitError("toolbox_utxo_invalid_address", { error: "Address not defined" });
 
     return address;
   };
@@ -453,8 +465,11 @@ function transfer(signer?: ChainSigner<Psbt, Psbt>) {
 
     const chain = assetValue.chain as UTXOChain;
 
-    if (!(signer && from)) throw new Error("From address must be provided");
-    if (!recipient) throw new Error("Recipient address must be provided");
+    if (!(signer && from)) throw new SwapKitError("toolbox_utxo_no_signer");
+    if (!recipient)
+      throw new SwapKitError("toolbox_utxo_invalid_params", {
+        error: "Recipient address must be provided",
+      });
     const txFeeRate = feeRate || (await getFeeRates(chain))[feeOptionKey || FeeOption.Fast];
 
     const { psbt } = await createTransaction({
@@ -476,8 +491,8 @@ async function getFeeRates(chain: UTXOChain) {
 
   return {
     [FeeOption.Average]: suggestedFeeRate,
-    [FeeOption.Fast]: suggestedFeeRate * 1.5,
-    [FeeOption.Fastest]: suggestedFeeRate * 2.0,
+    [FeeOption.Fast]: applyFeeMultiplier(suggestedFeeRate, FeeOption.Fast),
+    [FeeOption.Fastest]: applyFeeMultiplier(suggestedFeeRate, FeeOption.Fastest),
   };
 }
 

package/src/utxo/toolbox/zcash.ts

@@ -0,0 +1,208 @@
+import secp256k1 from "@bitcoinerlab/secp256k1";
+import { HDKey } from "@scure/bip32";
+import { mnemonicToSeedSync } from "@scure/bip39";
+import {
+  Chain,
+  type ChainSigner,
+  type DerivationPathArray,
+  FeeOption,
+  NetworkDerivationPath,
+  SKConfig,
+  SwapKitError,
+  derivationPathToString,
+  updateDerivationPath,
+} from "@swapkit/helpers";
+import type { Psbt } from "bitcoinjs-lib";
+import { hash160 } from "bitcoinjs-lib/src/crypto";
+import bs58check from "bs58check";
+import ECPairFactory from "ecpair";
+import { P, match } from "ts-pattern";
+import { getUtxoNetwork } from "../helpers";
+import type { UTXOBuildTxParams, UTXOTransferParams } from "../types";
+import { createUTXOToolbox } from "./utxo";
+
+const chain = Chain.Zcash;
+const network = getUtxoNetwork()(chain);
+
+/**
+ * Custom Zcash address generation that handles 2-byte prefixes
+ *
+ * Zcash transparent addresses use 2-byte version prefixes, unlike Bitcoin's single byte.
+ * This is incompatible with bitcoinjs-lib's payment methods which expect UInt8 values.
+ *
+ * @param publicKey - The public key buffer to generate address from
+ * @param isTestnet - Whether to generate testnet or mainnet address
+ * @returns A valid Zcash transparent address (t1... for mainnet, tm... for testnet)
+ */
+function generateZcashAddress(publicKey: Buffer, isTestnet = false): string {
+  // Hash the public key using RIPEMD160(SHA256(pubkey))
+  const publicKeyHash = hash160(publicKey);
+
+  // Zcash uses 2-byte prefixes for transparent addresses
+  // These prefixes ensure addresses start with expected characters when base58 encoded
+  const prefix = isTestnet
+    ? Buffer.from([0x1c, 0xba]) // testnet prefix (results in tm... addresses)
+    : Buffer.from([0x1c, 0xb8]); // mainnet prefix (results in t1... addresses)
+
+  // Combine prefix + hash (22 bytes total: 2 byte prefix + 20 byte hash)
+  const payload = Buffer.concat([prefix, publicKeyHash]);
+
+  // Encode with base58check for final address
+  return bs58check.encode(payload);
+}
+
+export function validateZcashAddress(address: string) {
+  try {
+    // Shielded addresses are not supported
+    if (address.startsWith("z")) {
+      console.warn(
+        "Shielded Zcash addresses (z-addresses) are not supported. Use transparent addresses (t1/t3) only.",
+      );
+      return false;
+    }
+
+    const isMainnet = address.startsWith("t1");
+    const isTestnet = address.startsWith("t3");
+
+    if (!(isMainnet || isTestnet)) {
+      return false;
+    }
+
+    // Verify network matches address type
+    const { isStagenet } = SKConfig.get("envs");
+    if ((isMainnet && isStagenet) || (isTestnet && !isStagenet)) {
+      return false;
+    }
+
+    return validateBase58Check(address, network);
+  } catch {
+    return false;
+  }
+}
+
+function validateBase58Check(
+  address: string,
+  network: ReturnType<ReturnType<typeof getUtxoNetwork>>,
+) {
+  try {
+    const decoded = bs58check.decode(address);
+
+    if (decoded.length < 21) {
+      return false;
+    }
+
+    const version = decoded[0];
+    return version === network.pubKeyHash || version === network.scriptHash;
+  } catch {
+    return false;
+  }
+}
+
+const ECPair = ECPairFactory(secp256k1);
+
+type ZcashSigner = ChainSigner<Psbt, Psbt>;
+
+async function createZcashSignerFromPhrase({
+  phrase,
+  derivationPathString,
+}: {
+  phrase: string;
+  derivationPathString: string;
+}) {
+  const seed = mnemonicToSeedSync(phrase);
+  const root = HDKey.fromMasterSeed(seed);
+
+  const node = root.derive(derivationPathString);
+
+  if (!node.privateKey) {
+    throw new Error("Unable to derive private key");
+  }
+
+  const keyPair = ECPair.fromPrivateKey(Buffer.from(node.privateKey), { network });
+
+  const { isStagenet } = SKConfig.get("envs");
+  const address = generateZcashAddress(keyPair.publicKey, isStagenet);
+
+  return {
+    getAddress() {
+      return Promise.resolve(address);
+    },
+
+    signTransaction(psbt: Psbt) {
+      for (let i = 0; i < psbt.inputCount; i++) {
+        psbt.signInput(i, keyPair);
+      }
+      return Promise.resolve(psbt);
+    },
+  };
+}
+
+export async function createZcashToolbox(
+  toolboxParams:
+    | {
+        signer?: ZcashSigner;
+      }
+    | {
+        phrase?: string;
+        derivationPath?: DerivationPathArray;
+        index?: number;
+      },
+) {
+  const signer = await match(toolboxParams)
+    .with({ signer: P.not(P.nullish) }, ({ signer }) => Promise.resolve(signer))
+    .with({ phrase: P.string }, ({ phrase, derivationPath, index = 0 }) => {
+      // Handle derivation path processing at toolbox level
+      const baseDerivationPath = derivationPath ||
+        NetworkDerivationPath[Chain.Zcash] || [44, 133, 0, 0, 0];
+      const updatedDerivationPath = updateDerivationPath(baseDerivationPath, { index });
+      const derivationPathString = derivationPathToString(updatedDerivationPath);
+
+      return createZcashSignerFromPhrase({ phrase, derivationPathString });
+    })
+    .otherwise(() => Promise.resolve(undefined));
+
+  const { getFeeRates, broadcastTx, ...toolbox } = await createUTXOToolbox({
+    chain: Chain.Zcash,
+    signer,
+  });
+
+  function getAddressFromKeys(keys: { getAddress: () => string }) {
+    return keys.getAddress();
+  }
+
+  async function transfer({
+    recipient,
+    assetValue,
+    feeOptionKey = FeeOption.Fast,
+    ...rest
+  }: UTXOTransferParams) {
+    const from = await signer?.getAddress();
+    if (!(signer && from)) throw new SwapKitError("toolbox_utxo_no_signer");
+
+    const feeRate = rest.feeRate || (await getFeeRates())[feeOptionKey];
+
+    const buildTxParams: UTXOBuildTxParams = {
+      ...rest,
+      assetValue,
+      feeRate,
+      recipient,
+      sender: from,
+    };
+
+    const { psbt } = await toolbox.createTransaction(buildTxParams);
+    const signedPsbt = await signer.signTransaction(psbt);
+    signedPsbt.finalizeAllInputs();
+    const txHex = signedPsbt.extractTransaction().toHex();
+
+    return broadcastTx(txHex);
+  }
+
+  return {
+    ...toolbox,
+    broadcastTx,
+    getFeeRates,
+    transfer,
+    getAddressFromKeys,
+    validateAddress: validateZcashAddress,
+  };
+}

package/src/utxo/types.ts

@@ -52,4 +52,6 @@ export type TransactionBuilderType = {
     signatureAlgorithm?: string,
   ): void;
   build(): TransactionType;
+  addOutput(addressOrScriptBuffer: string | Buffer, value: number): void;
+  addInput(txHash: string | Buffer, vout: number, sequence?: number, prevOutScript?: Buffer): void;
 };

package/dist/chunk-0h4xdrwz.js

@@ -1,4 +0,0 @@
-import{AssetValue as c,BaseDecimal as p}from"@swapkit/helpers";import{SwapKitApi as u}from"@swapkit/helpers/api";var l=typeof process!=="undefined"&&process.pid?process.pid.toString(36):"",a=0;function g(){function t(){let e=Date.now(),n=a||e;return a=n,e>a?e:n+1}return l+t().toString(36)}function w(t){return async function e(n,i=!0){return(await u.getChainBalance({chain:t,address:n,scamFilter:i})).map(({identifier:r,value:o,decimal:s})=>{return new c({decimal:s||p[t],value:o,identifier:r})})}}
-export{g as a,w as b};
-
-//# debugId=7D1F4061F0771C8264756E2164756E21