@swapkit/toolboxes 0.0.0-nightly-20250304130539

package/src/substrate/types/wallet.ts

@@ -0,0 +1,78 @@
+import type { Signer as InjectedSigner } from "@polkadot/api/types";
+import type { ProviderInterface } from "@polkadot/rpc-provider/types";
+import type { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import type { KeypairType } from "@polkadot/util-crypto/types";
+
+type This = typeof globalThis;
+
+export type Unsubcall = () => void;
+
+export interface InjectedAccount {
+  address: string;
+  genesisHash?: string | null;
+  name?: string;
+  type?: KeypairType;
+}
+
+export interface InjectedAccounts {
+  get: (anyType?: boolean) => Promise<InjectedAccount[]>;
+  subscribe: (cb: (accounts: InjectedAccount[]) => void | Promise<void>) => Unsubcall;
+}
+export interface InjectedExtensionInfo {
+  name: string;
+  version: string;
+}
+export interface ProviderMeta {
+  network: string;
+  node: "full" | "light";
+  source: string;
+  transport: string;
+}
+export interface MetadataDefBase {
+  chain: string;
+  genesisHash: string;
+  icon: string;
+  ss58Format: number;
+  chainType?: "substrate" | "ethereum";
+}
+export interface MetadataDef extends MetadataDefBase {
+  color?: string;
+  specVersion: number;
+  tokenDecimals: number;
+  tokenSymbol: string;
+  types: Record<string, Record<string, string> | string>;
+  metaCalls?: string;
+  userExtensions?: ExtDef;
+}
+export interface InjectedMetadataKnown {
+  genesisHash: string;
+  specVersion: number;
+}
+export interface InjectedMetadata {
+  get: () => Promise<InjectedMetadataKnown[]>;
+  provide: (definition: MetadataDef) => Promise<boolean>;
+}
+export type ProviderList = Record<string, ProviderMeta>;
+export interface InjectedProvider extends ProviderInterface {
+  listProviders: () => Promise<ProviderList>;
+  startProvider: (key: string) => Promise<ProviderMeta>;
+}
+export interface InjectedProviderWithMeta {
+  provider: InjectedProvider;
+  meta: ProviderMeta;
+}
+export interface Injected {
+  accounts: InjectedAccounts;
+  metadata?: InjectedMetadata;
+  provider?: InjectedProvider;
+  signer: InjectedSigner;
+}
+export interface InjectedWindowProvider {
+  connect?: (origin: string) => Promise<InjectedExtension>;
+  enable?: (origin: string) => Promise<Injected>;
+  version?: string;
+}
+export interface InjectedWindow extends This {
+  injectedWeb3: Record<string, InjectedWindowProvider>;
+}
+export type InjectedExtension = InjectedExtensionInfo & Injected;

package/src/utxo/helpers/api.ts

@@ -0,0 +1,431 @@
+import { Chain, RequestClient, SKConfig, type UTXOChain, warnOnce } from "@swapkit/helpers";
+import { uniqid } from "./utils";
+
+type BlockchairParams<T> = T & { chain: Chain; apiKey?: string };
+type BlockchairFetchUnspentUtxoParams = BlockchairParams<{
+  offset?: number;
+  limit?: number;
+  address: string;
+}>;
+
+async function broadcastUTXOTx({ chain, txHash }: { chain: Chain; txHash: string }) {
+  const rpcUrl = SKConfig.get("rpcUrls")[chain];
+  const body = JSON.stringify({
+    jsonrpc: "2.0",
+    method: "sendrawtransaction",
+    params: [txHash],
+    id: uniqid(),
+  });
+
+  const response = await RequestClient.post<{
+    id: string;
+    result: string;
+    error: { message: string; code?: number } | null;
+  }>(rpcUrl, { headers: { "Content-Type": "application/json" }, body });
+
+  if (response.error) {
+    throw new Error(`failed to broadcast a transaction: ${response.error?.message}`);
+  }
+
+  if (response.result.includes('"code":-26')) {
+    throw new Error("Invalid transaction: the transaction amount was too low");
+  }
+
+  return response.result;
+}
+
+function baseUrl(chain: Chain) {
+  return `https://api.blockchair.com/${mapChainToBlockchairChain(chain)}`;
+}
+
+function getDefaultTxFeeByChain(chain: Chain) {
+  switch (chain) {
+    case Chain.Bitcoin:
+      return 5;
+    case Chain.Dogecoin:
+      return 10000;
+    case Chain.Litecoin:
+      return 1;
+    default:
+      return 2;
+  }
+}
+
+function mapChainToBlockchairChain(chain: Chain) {
+  switch (chain) {
+    case Chain.BitcoinCash:
+      return "bitcoin-cash";
+    case Chain.Litecoin:
+      return "litecoin";
+    case Chain.Dash:
+      return "dash";
+    case Chain.Dogecoin:
+      return "dogecoin";
+    case Chain.Polkadot:
+      return "polkadot";
+    default:
+      return "bitcoin";
+  }
+}
+
+async function getSuggestedTxFee(chain: Chain) {
+  try {
+    //Use Bitgo API for fee estimation
+    //Refer: https://app.bitgo.com/docs/#operation/v2.tx.getfeeestimate
+    const { feePerKb } = await RequestClient.get<{
+      feePerKb: number;
+      cpfpFeePerKb: number;
+      numBlocks: number;
+      feeByBlockTarget: { 1: number; 3: number };
+    }>(`https://app.bitgo.com/api/v2/${chain.toLowerCase()}/tx/fee`);
+    const suggestedFee = feePerKb / 1000;
+
+    return Math.max(suggestedFee, getDefaultTxFeeByChain(chain));
+  } catch (_error) {
+    return getDefaultTxFeeByChain(chain);
+  }
+}
+
+async function blockchairRequest<T>(url: string, apiKey?: string): Promise<T> {
+  try {
+    const response = await RequestClient.get<BlockchairResponse<T>>(url);
+    if (!response || response.context.code !== 200) throw new Error(`failed to query ${url}`);
+
+    return response.data as T;
+  } catch (error) {
+    if (!apiKey) throw error;
+    const response = await RequestClient.get<BlockchairResponse<T>>(
+      `${url}${apiKey ? `&key=${apiKey}` : ""}`,
+    );
+
+    if (!response || response.context.code !== 200) throw new Error(`failed to query ${url}`);
+
+    return response.data as T;
+  }
+}
+
+async function getAddressData({ address, chain, apiKey }: BlockchairParams<{ address?: string }>) {
+  if (!address) throw new Error("address is required");
+
+  try {
+    const response = await blockchairRequest<BlockchairAddressResponse>(
+      `${baseUrl(chain)}/dashboards/address/${address}?transaction_details=true`,
+      apiKey,
+    );
+
+    return response[address];
+  } catch (_error) {
+    return { utxo: [], address: { balance: 0, transaction_count: 0 } };
+  }
+}
+
+async function getUnconfirmedBalance({
+  address,
+  chain,
+  apiKey,
+}: BlockchairParams<{ address?: string }>) {
+  const response = await getAddressData({ address, chain, apiKey });
+
+  return response?.address.balance || 0;
+}
+
+async function getConfirmedBalance({
+  chain,
+  address,
+  apiKey,
+}: BlockchairParams<{ address?: string }>) {
+  if (!address) throw new Error("address is required");
+
+  try {
+    const response = await blockchairRequest<BlockchairMultipleBalancesResponse>(
+      `${baseUrl(chain)}/addresses/balances?addresses=${address}`,
+      apiKey,
+    );
+
+    return response[address] || 0;
+  } catch (_error) {
+    return 0;
+  }
+}
+
+async function getRawTx({ chain, apiKey, txHash }: BlockchairParams<{ txHash?: string }>) {
+  if (!txHash) throw new Error("txHash is required");
+
+  try {
+    const rawTxResponse = await blockchairRequest<BlockchairRawTransactionResponse>(
+      `${baseUrl(chain)}/raw/transaction/${txHash}`,
+      apiKey,
+    );
+    return rawTxResponse?.[txHash]?.raw_transaction || "";
+  } catch (error) {
+    console.error(error);
+    return "";
+  }
+}
+
+async function fetchUnspentUtxoBatch({
+  chain,
+  address,
+  apiKey,
+  offset = 0,
+  limit = 100,
+}: BlockchairFetchUnspentUtxoParams) {
+  const response = await blockchairRequest<BlockchairOutputsResponse[]>(
+    `${baseUrl(chain)}/outputs?q=is_spent(false),recipient(${address})&limit=${limit}&offset=${offset}`,
+    apiKey,
+  );
+
+  const txs = response
+    .filter(({ is_spent }) => !is_spent)
+    .map(({ script_hex, block_id, transaction_hash, index, value, spending_signature_hex }) => ({
+      hash: transaction_hash,
+      index,
+      value,
+      txHex: spending_signature_hex,
+      script_hex,
+      is_confirmed: block_id !== -1,
+    }));
+
+  return txs;
+}
+
+async function getUnspentUtxos({
+  chain,
+  address,
+  apiKey,
+  offset = 0,
+  limit = 100,
+}: BlockchairFetchUnspentUtxoParams): Promise<Awaited<ReturnType<typeof fetchUnspentUtxoBatch>>> {
+  if (!address) throw new Error("address is required");
+
+  try {
+    const txs = await fetchUnspentUtxoBatch({ chain, address, apiKey, offset, limit });
+
+    if (txs.length <= limit) return txs;
+
+    const nextBatch = await getUnspentUtxos({
+      chain,
+      address,
+      apiKey,
+      offset: offset + limit,
+      limit,
+    });
+
+    return [...txs, ...nextBatch];
+  } catch (error) {
+    console.error(error);
+    return [];
+  }
+}
+
+async function scanUTXOs({
+  address,
+  chain,
+  apiKey,
+  fetchTxHex = true,
+}: BlockchairParams<{ address: string; fetchTxHex?: boolean }>) {
+  const utxos = await getUnspentUtxos({ chain, address, apiKey });
+  const results = [];
+
+  for (const { hash, index, script_hex, value } of utxos) {
+    let txHex: string | undefined;
+    if (fetchTxHex) {
+      txHex = await getRawTx({ txHash: hash, chain, apiKey });
+    }
+    results.push({
+      address,
+      hash,
+      index,
+      txHex,
+      value,
+      witnessUtxo: { value, script: Buffer.from(script_hex, "hex") },
+    });
+  }
+  return results;
+}
+
+function utxoApi(chain: UTXOChain) {
+  const apiKey = SKConfig.get("apiKeys").blockchair || "";
+
+  warnOnce(!apiKey, "No Blockchair API key found. Functionality will be limited.");
+
+  return {
+    broadcastTx: (txHash: string) => broadcastUTXOTx({ txHash, chain }),
+    getConfirmedBalance: (address: string) => getConfirmedBalance({ chain, address, apiKey }),
+    getRawTx: (txHash: string) => getRawTx({ txHash, chain, apiKey }),
+    getSuggestedTxFee: () => getSuggestedTxFee(chain),
+    getBalance: (address: string) => getUnconfirmedBalance({ address, chain, apiKey }),
+    getAddressData: (address: string) => getAddressData({ address, chain, apiKey }),
+    scanUTXOs: (params: { address: string; fetchTxHex?: boolean }) =>
+      scanUTXOs({ ...params, chain, apiKey }),
+  };
+}
+
+/**
+ * "Factory" to ensure typing for custom UTXO APIs
+ */
+export function createCustomUtxoApi(methods: ReturnType<typeof utxoApi>) {
+  return methods;
+}
+
+export function getUtxoApi(chain: UTXOChain) {
+  const customUtxoApi = SKConfig.get("apis")[chain];
+
+  if (customUtxoApi) {
+    warnOnce(true, "Using custom UTXO API. Be sure to implement all methods to avoid issues.");
+    return customUtxoApi as ReturnType<typeof utxoApi>;
+  }
+
+  return utxoApi(chain);
+}
+
+interface BlockchairMultipleBalancesResponse {
+  [key: string]: number;
+}
+
+interface BlockchairVin {
+  txid: string;
+  vout: number;
+  scriptSig: {
+    asm: string;
+    hex: string;
+  };
+  sequence: number;
+}
+
+interface BlockchairVout {
+  value: number;
+  n: number;
+  scriptPubKey: {
+    asm: string;
+    hex: string;
+    address: string;
+    type: string;
+    addresses: string[];
+    reqSigs: number;
+  };
+}
+
+interface BlockchairTransaction {
+  block_id: number;
+  hash: string;
+  time: string;
+  balance_change: number;
+}
+
+interface BlockchairUtxo {
+  block_id: number;
+  transaction_hash: string;
+  index: number;
+  value: number;
+}
+
+interface BlockchairAddressCoreData {
+  type: string;
+  script_hex: string;
+  balance: number;
+  balance_usd: number;
+  received: number;
+  received_usd: number;
+  spent: number;
+  spent_usd: number;
+  output_count: number;
+  unspent_output_count: number;
+  first_seen_receiving: string;
+  last_seen_receiving: string;
+  first_seen_spending: null | string;
+  last_seen_spending: null | string;
+  transaction_count: number;
+  scripthash_type: null | string;
+}
+
+interface BlockchairInputOutputCommonData {
+  block_id: number;
+  transaction_id: number;
+  index: number;
+  transaction_hash: string;
+  date: string;
+  time: string;
+  value: number;
+  value_usd: number;
+  recipient: string;
+  type: string;
+  script_hex: string;
+  is_from_coinbase: boolean;
+  is_spendable: boolean | null;
+  is_spent: boolean;
+  lifespan: number | null;
+  cdd: number | null;
+}
+
+interface BlockchairSpendingBlockData {
+  spending_block_id: number | null;
+  spending_transaction_id: number | null;
+  spending_index: number | null;
+  spending_transaction_hash: string | null;
+  spending_date: string | null;
+  spending_time: string | null;
+  spending_value_usd: number | null;
+  spending_sequence: number | null;
+  spending_signature_hex: string | null;
+  spending_witness: string | null;
+}
+
+interface BlockchairAddressResponse {
+  [key: string]: {
+    address: BlockchairAddressCoreData;
+    transactions: BlockchairTransaction[];
+    utxo: BlockchairUtxo[];
+  };
+}
+
+interface BlockchairOutputsResponse
+  extends BlockchairSpendingBlockData,
+    BlockchairInputOutputCommonData {}
+
+interface BlockchairRawTransactionResponse {
+  [key: string]: {
+    raw_transaction: string;
+    decoded_raw_transaction: {
+      txid: string;
+      hash: string;
+      version: number;
+      size: number;
+      vsize: number;
+      weight: number;
+      locktime: number;
+      vin: BlockchairVin[];
+      vout: BlockchairVout[];
+    };
+  };
+}
+
+interface BlockchairResponse<T> {
+  data: T;
+  context: {
+    code: number;
+    source: string;
+    results: number;
+    state: number;
+    market_price_usd: number;
+    cache: {
+      live: boolean;
+      duration: number;
+      since: string;
+      until: string;
+      time: any;
+    };
+    api: {
+      version: string;
+      last_major_update: string;
+      next_major_update: null | string;
+      documentation: string;
+      notice: string;
+    };
+    servers: string;
+    time: number;
+    render_time: number;
+    full_time: number;
+    request_cost: number;
+  };
+}

package/src/utxo/helpers/bchaddrjs.ts

@@ -0,0 +1,177 @@
+import base58check from "bs58check";
+// @ts-expect-error
+import cashaddr from "cashaddrjs";
+
+enum Format {
+  Legacy = "legacy",
+  Bitpay = "bitpay",
+  Cashaddr = "cashaddr",
+}
+enum Network {
+  Mainnet = "mainnet",
+  Testnet = "testnet",
+}
+enum Type {
+  P2PKH = "p2pkh",
+  P2SH = "p2sh",
+}
+
+const VERSION_BYTE = {
+  [Format.Legacy]: {
+    [Network.Mainnet]: {
+      [Type.P2PKH]: 0,
+      [Type.P2SH]: 5,
+    },
+    [Network.Testnet]: {
+      [Type.P2PKH]: 111,
+      [Type.P2SH]: 196,
+    },
+  },
+  [Format.Bitpay]: {
+    [Network.Mainnet]: {
+      [Type.P2PKH]: 28,
+      [Type.P2SH]: 40,
+    },
+    [Network.Testnet]: {
+      [Type.P2PKH]: 111,
+      [Type.P2SH]: 196,
+    },
+  },
+};
+
+type DecodedType = {
+  format: Format;
+  network: Network;
+  type: Type;
+  hash: any;
+};
+
+function isValidAddress(input: any) {
+  try {
+    decodeAddress(input);
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+
+function detectAddressNetwork(address: string) {
+  return decodeAddress(address)?.network;
+}
+
+function toLegacyAddress(address: string): string {
+  const decoded = decodeAddress(address);
+  if (decoded?.format === Format.Legacy) {
+    return address;
+  }
+  return encodeAsLegacy(decoded);
+}
+
+function toCashAddress(address: string): string {
+  const decoded = decodeAddress(address);
+  return encodeAsCashaddr(decoded);
+}
+
+function decodeAddress(address: string) {
+  try {
+    return decodeBase58Address(address);
+  } catch (_error) {
+    // Try to decode as cashaddr if base58 decoding fails.
+  }
+  try {
+    return decodeCashAddress(address);
+  } catch (_error) {
+    // Try to decode as bitpay if cashaddr decoding fails.
+  }
+  throw new Error("Received an invalid Bitcoin Cash address as input.");
+}
+
+function decodeBase58Address(address: string) {
+  try {
+    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.");
+    const versionByte = payload[0];
+    const hash = Array.prototype.slice.call(payload, 1);
+
+    switch (versionByte) {
+      case VERSION_BYTE[Format.Legacy][Network.Mainnet][Type.P2PKH]:
+        return { hash, format: Format.Legacy, network: Network.Mainnet, type: Type.P2PKH };
+
+      case VERSION_BYTE[Format.Legacy][Network.Mainnet][Type.P2SH]:
+        return { hash, format: Format.Legacy, network: Network.Mainnet, type: Type.P2SH };
+
+      case VERSION_BYTE[Format.Legacy][Network.Testnet][Type.P2PKH]:
+        return { hash, format: Format.Legacy, network: Network.Testnet, type: Type.P2PKH };
+
+      case VERSION_BYTE[Format.Legacy][Network.Testnet][Type.P2SH]:
+        return { hash, format: Format.Legacy, network: Network.Testnet, type: Type.P2SH };
+
+      case VERSION_BYTE[Format.Bitpay][Network.Mainnet][Type.P2PKH]:
+        return { hash, format: Format.Bitpay, network: Network.Mainnet, type: Type.P2PKH };
+
+      case VERSION_BYTE[Format.Bitpay][Network.Mainnet][Type.P2SH]:
+        return { hash, format: Format.Bitpay, network: Network.Mainnet, type: Type.P2SH };
+
+      default:
+        throw new Error("Received an invalid Bitcoin Cash address as input.");
+    }
+  } catch (_error) {
+    throw new Error("Received an invalid Bitcoin Cash address as input.");
+  }
+}
+
+function decodeCashAddress(address: string) {
+  if (address.indexOf(":") !== -1) {
+    try {
+      return decodeCashAddressWithPrefix(address);
+    } catch (_error) {
+      // Try to decode as legacy if cashaddr decoding fails.
+    }
+  } else {
+    const prefixes = ["bitcoincash", "bchtest", "bchreg"];
+    for (const prefix of prefixes) {
+      try {
+        return decodeCashAddressWithPrefix(`${prefix}:${address}`);
+      } catch (_error) {
+        // Try next prefix if decoding fails.
+      }
+    }
+  }
+
+  throw new Error("Received an invalid Bitcoin Cash address as input.");
+}
+
+function decodeCashAddressWithPrefix(address: string): DecodedType {
+  try {
+    const { hash, prefix, type } = cashaddr.decode(address);
+
+    return {
+      format: Format.Cashaddr,
+      hash: Array.prototype.slice.call(hash, 0),
+      network: prefix === "bitcoincash" ? Network.Mainnet : Network.Testnet,
+      type: type === "P2PKH" ? Type.P2PKH : Type.P2SH,
+    };
+  } catch (_error) {
+    throw new Error("Received an invalid Bitcoin Cash address as input.");
+  }
+}
+
+function encodeAsLegacy(decoded: DecodedType) {
+  const versionByte = VERSION_BYTE[Format.Legacy][decoded.network][decoded.type];
+  const buffer = Buffer.alloc(1 + decoded.hash.length);
+  buffer[0] = versionByte;
+  buffer.set(decoded.hash, 1);
+  return base58check.encode(buffer);
+}
+
+function encodeAsCashaddr(decoded: DecodedType) {
+  const prefix = decoded.network === Network.Mainnet ? "bitcoincash" : "bchtest";
+  const type = decoded.type === Type.P2PKH ? "P2PKH" : "P2SH";
+  const hash = new Uint8Array(decoded.hash);
+  return cashaddr.encode(prefix, type, hash);
+}
+
+export { detectAddressNetwork, isValidAddress, Network, toCashAddress, toLegacyAddress };