@swapkit/toolboxes 4.3.9 → 4.13.1

package/src/utxo/toolbox/zcash.ts

@@ -1,242 +0,0 @@
-import { bitgo, crypto, ECPair, networks, address as zcashAddress } from "@bitgo/utxo-lib";
-import type { ZcashPsbt } from "@bitgo/utxo-lib/dist/src/bitgo";
-import { HDKey } from "@scure/bip32";
-import { mnemonicToSeedSync } from "@scure/bip39";
-import {
-  Chain,
-  type ChainSigner,
-  type DerivationPathArray,
-  derivationPathToString,
-  FeeOption,
-  NetworkDerivationPath,
-  SKConfig,
-  SwapKitError,
-  updateDerivationPath,
-} from "@swapkit/helpers";
-import bs58check from "bs58check";
-import { match, P } from "ts-pattern";
-import { accumulative, compileMemo, getUtxoApi } from "../helpers";
-import type { TargetOutput, UTXOBuildTxParams, UTXOTransferParams, UTXOType } from "../types";
-import { createUTXOToolbox } from "./utxo";
-import { validateZcashAddress } from "./validators";
-
-function getZcashNetwork() {
-  return networks.zcash;
-}
-
-function getECPairNetwork() {
-  return {
-    bech32: undefined,
-    bip32: { private: 0x0488ade4, public: 0x0488b21e },
-    messagePrefix: "\x18ZCash Signed Message:\n",
-    pubKeyHash: 0x1c,
-    scriptHash: 0x1c,
-    wif: 0x80,
-  };
-}
-
-type ZcashSigner = ChainSigner<ZcashPsbt, ZcashPsbt>;
-
-function createZcashSignerFromPhrase({
-  phrase,
-  derivationPath,
-}: {
-  phrase: string;
-  derivationPath: string;
-}): ZcashSigner {
-  const seed = mnemonicToSeedSync(phrase);
-  const root = HDKey.fromMasterSeed(seed);
-  const node = root.derive(derivationPath);
-
-  if (!node.privateKey) {
-    throw new SwapKitError("toolbox_utxo_invalid_params");
-  }
-
-  // Create key pair using BitGo's ECPair with ECPair-compatible network
-  const ecpairNetwork = getECPairNetwork();
-  const keyPair = ECPair.fromPrivateKey(Buffer.from(node.privateKey), { network: ecpairNetwork });
-
-  const pubKeyHash = crypto.hash160(keyPair.publicKey);
-  const { isStagenet } = SKConfig.get("envs");
-
-  const prefix = isStagenet
-    ? Buffer.from([0x1d, 0x25]) // testnet prefix (results in tm... addresses)
-    : Buffer.from([0x1c, 0xb8]); // mainnet prefix (results in t1... addresses)
-
-  const payload = Buffer.concat([prefix, pubKeyHash]);
-
-  const address = bs58check.encode(payload);
-
-  return {
-    getAddress: () => Promise.resolve(address),
-
-    signTransaction: (psbt) => {
-      const signedPsbt = psbt.signAllInputs(keyPair);
-
-      return Promise.resolve(signedPsbt);
-    },
-  };
-}
-
-function addInputsAndOutputs({
-  inputs,
-  outputs,
-  psbt,
-  sender,
-  compiledMemo,
-}: {
-  inputs: UTXOType[];
-  outputs: TargetOutput[];
-  psbt: ZcashPsbt;
-  sender: string;
-  compiledMemo: Buffer<ArrayBufferLike> | null;
-}) {
-  for (const utxo of inputs) {
-    const witnessInfo = !!utxo.witnessUtxo && { witnessUtxo: { ...utxo.witnessUtxo, value: BigInt(utxo.value) } };
-
-    const nonWitnessInfo = !utxo.witnessUtxo && {
-      nonWitnessUtxo: utxo.txHex ? Buffer.from(utxo.txHex, "hex") : undefined,
-    };
-
-    psbt.addInput({ hash: utxo.hash, index: utxo.index, ...witnessInfo, ...nonWitnessInfo });
-  }
-
-  for (const output of outputs) {
-    const address = "address" in output && output.address ? output.address : sender;
-    const hasOutputScript = output.script;
-
-    if (hasOutputScript && !compiledMemo) {
-      continue;
-    }
-
-    const mappedOutput = hasOutputScript
-      ? { script: compiledMemo as Buffer<ArrayBufferLike>, value: 0n }
-      : { script: zcashAddress.toOutputScript(address, getZcashNetwork()), value: BigInt(output.value) };
-
-    psbt.addOutput(mappedOutput);
-  }
-
-  return { inputs, psbt };
-}
-
-async function createTransaction(buildTxParams: UTXOBuildTxParams) {
-  const { assetValue, recipient, memo, feeRate, sender, fetchTxHex } = buildTxParams;
-
-  const compiledMemo = memo ? compileMemo(memo) : null;
-
-  const utxos = await getUtxoApi(Chain.Zcash).getUtxos({ address: sender, fetchTxHex: fetchTxHex !== false });
-
-  const targetOutputs = [
-    { address: recipient, value: Number(assetValue.getBaseValue("string")) },
-    ...(compiledMemo ? [{ script: compiledMemo, value: 0 }] : []),
-  ];
-
-  const { inputs, outputs } = accumulative({
-    chain: Chain.Zcash,
-    changeAddress: sender, // Overwrite change address to sender
-    feeRate,
-    inputs: utxos,
-    outputs: targetOutputs,
-  });
-
-  if (!(inputs && outputs)) {
-    throw new SwapKitError("toolbox_utxo_insufficient_balance", { assetValue, sender });
-  }
-
-  const psbt = bitgo.createPsbtForNetwork({ network: getZcashNetwork() }, { version: 455 }) as ZcashPsbt;
-
-  const branchId = 0x4dec4df0;
-
-  const CONSENSUS_BRANCH_ID_KEY = Buffer.concat([Buffer.of(0xfc), Buffer.of(0x05), Buffer.from("BITGO"), Buffer.of(0)]);
-
-  // PSBT value must be 4-byte little-endian
-  const value = Buffer.allocUnsafe(4);
-  value.writeUInt32LE(branchId >>> 0, 0);
-
-  psbt.addUnknownKeyValToGlobal({ key: CONSENSUS_BRANCH_ID_KEY, value });
-
-  const { psbt: mappedPsbt, inputs: mappedInputs } = await addInputsAndOutputs({
-    compiledMemo,
-    inputs,
-    outputs,
-    psbt,
-    sender,
-  });
-
-  return { inputs: mappedInputs, outputs, psbt: mappedPsbt };
-}
-
-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 }) => {
-      const baseDerivationPath = derivationPath || NetworkDerivationPath[Chain.Zcash] || [44, 133, 0, 0, 0];
-      const updatedPath = updateDerivationPath(baseDerivationPath, { index });
-      const pathString = derivationPathToString(updatedPath);
-
-      return createZcashSignerFromPhrase({ derivationPath: pathString, phrase });
-    })
-    .otherwise(() => Promise.resolve(undefined));
-
-  const baseToolbox = await createUTXOToolbox({ chain: Chain.Zcash, signer });
-
-  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 baseToolbox.getFeeRates())[feeOptionKey];
-
-    const { psbt } = await createTransaction({ ...rest, assetValue, feeRate, recipient, sender: from });
-
-    const signedPsbt = await signer.signTransaction(psbt);
-
-    signedPsbt.finalizeAllInputs();
-
-    return baseToolbox.broadcastTx(signedPsbt.extractTransaction().toHex());
-  }
-
-  function createKeysForPath({
-    phrase,
-    derivationPath = "m/44'/133'/0'/0/0",
-  }: {
-    phrase: string;
-    derivationPath?: string;
-  }) {
-    const seed = mnemonicToSeedSync(phrase);
-    const root = HDKey.fromMasterSeed(seed);
-    const node = root.derive(derivationPath);
-
-    if (!node.privateKey) {
-      throw new SwapKitError("toolbox_utxo_invalid_params");
-    }
-
-    const ecpairNetwork = getECPairNetwork();
-    const keyPair = ECPair.fromPrivateKey(Buffer.from(node.privateKey), { network: ecpairNetwork });
-
-    return keyPair;
-  }
-
-  function getPrivateKeyFromMnemonic({
-    phrase,
-    derivationPath = "m/44'/133'/0'/0/0",
-  }: {
-    phrase: string;
-    derivationPath: string;
-  }) {
-    const keys = createKeysForPath({ derivationPath, phrase });
-    return keys.toWIF();
-  }
-
-  return {
-    ...baseToolbox,
-    createKeysForPath,
-    createTransaction,
-    getPrivateKeyFromMnemonic,
-    transfer,
-    validateAddress: validateZcashAddress,
-  };
-}

package/src/utxo/types.ts

@@ -1,39 +0,0 @@
-import type { GenericCreateTransactionParams, GenericTransferParams, Witness } from "@swapkit/helpers";
-
-import type { UTXOScriptType } from "./helpers";
-
-export type TransactionType = { toHex(): string };
-
-export type TargetOutput = { address: string; script?: Buffer; value: number } | { script: Buffer; value: number };
-
-export type UTXOType = { hash: string; index: number; value: number; txHex?: string; witnessUtxo?: Witness };
-
-export type UTXOInputWithScriptType = UTXOType & { type: UTXOScriptType; address: string };
-
-export type UTXOCalculateTxSizeParams = {
-  inputs: (UTXOInputWithScriptType | UTXOType)[];
-  outputs?: TargetOutput[];
-  feeRate: number;
-};
-
-export type UTXOBuildTxParams = GenericCreateTransactionParams & { fetchTxHex?: boolean };
-
-export type UTXOTransferParams = GenericTransferParams;
-
-export type BchECPair = { getAddress: (index?: number) => string; publicKey: Buffer; toWIF: () => string };
-
-export type TransactionBuilderType = {
-  inputs: any[];
-  sign(
-    vin: number,
-    keyPair: BchECPair,
-    redeemScript?: Buffer,
-    hashType?: number,
-    witnessValue?: number,
-    witnessScript?: Buffer,
-    signatureAlgorithm?: string,
-  ): void;
-  build(): TransactionType;
-  addOutput(addressOrScriptBuffer: string | Buffer, value: number): void;
-  addInput(txHash: string | Buffer, vout: number, sequence?: number, prevOutScript?: Buffer): void;
-};