@swapkit/toolboxes 1.0.0-beta.0 → 1.0.0-beta.10

package/src/index.ts

@@ -0,0 +1,235 @@
+import {
+  AssetValue,
+  Chain,
+  type CosmosChain,
+  type EVMChain,
+  FeeOption,
+  type GenericCreateTransactionParams,
+  type SubstrateChain,
+  type UTXOChain,
+} from "@swapkit/helpers";
+import type { getCosmosToolbox } from "@swapkit/toolboxes/cosmos";
+
+import type { ETHToolbox, EVMCreateTransactionParams, getEvmToolbox } from "@swapkit/toolboxes/evm";
+import type { RadixToolbox } from "@swapkit/toolboxes/radix";
+import type { getRippleToolbox } from "@swapkit/toolboxes/ripple";
+import type { SolanaCreateTransactionParams, getSolanaToolbox } from "@swapkit/toolboxes/solana";
+import type { getSubstrateToolbox } from "@swapkit/toolboxes/substrate";
+import type { getUtxoToolbox } from "@swapkit/toolboxes/utxo";
+
+export async function getAddressValidator() {
+  const { match } = await import("ts-pattern");
+  const { cosmosValidateAddress } = await import("@swapkit/toolboxes/cosmos");
+  const { evmValidateAddress } = await import("@swapkit/toolboxes/evm");
+  const { substrateValidateAddress } = await import("@swapkit/toolboxes/substrate");
+  const { getUTXOAddressValidator } = await import("@swapkit/toolboxes/utxo");
+  const { getSolanaAddressValidator } = await import("@swapkit/toolboxes/solana");
+  const { rippleValidateAddress } = await import("@swapkit/toolboxes/ripple");
+  const { radixValidateAddress } = await import("@swapkit/toolboxes/radix");
+
+  const solanaValidateAddress = await getSolanaAddressValidator();
+  const utxoValidateAddress = await getUTXOAddressValidator();
+
+  return function validateAddress({ address, chain }: { address: string; chain: Chain }) {
+    const isValid = match(chain)
+      .with(
+        Chain.Arbitrum,
+        Chain.Avalanche,
+        Chain.Optimism,
+        Chain.BinanceSmartChain,
+        Chain.Base,
+        Chain.Polygon,
+        Chain.Ethereum,
+        () => evmValidateAddress({ address }),
+      )
+      .with(Chain.Litecoin, Chain.Dash, Chain.Dogecoin, Chain.BitcoinCash, Chain.Bitcoin, () =>
+        utxoValidateAddress({ address, chain: chain as UTXOChain }),
+      )
+      .with(Chain.Cosmos, Chain.Kujira, Chain.Maya, Chain.THORChain, () =>
+        cosmosValidateAddress({ address, chain: chain as CosmosChain }),
+      )
+      .with(Chain.Chainflip, Chain.Polkadot, () =>
+        substrateValidateAddress({ address, chain: chain as SubstrateChain }),
+      )
+      .with(Chain.Radix, () => radixValidateAddress(address))
+      .with(Chain.Ripple, () => rippleValidateAddress(address))
+      .with(Chain.Solana, () => solanaValidateAddress(address))
+      .otherwise(() => false);
+
+    return isValid;
+  };
+}
+
+export async function getFeeEstimator<T extends keyof CreateTransactionParams>(chain: T) {
+  const toolbox = await getToolbox(chain);
+
+  return async function estimateFee(params: CreateTransactionParams[T]) {
+    switch (chain) {
+      case Chain.Arbitrum:
+      case Chain.Avalanche:
+      case Chain.Optimism:
+      case Chain.BinanceSmartChain:
+      case Chain.Base:
+      case Chain.Polygon:
+      case Chain.Ethereum: {
+        const txObject = await (
+          toolbox as Awaited<ReturnType<typeof ETHToolbox>>
+        ).createTransaction(params as EVMCreateTransactionParams);
+        return (toolbox as Awaited<ReturnType<typeof ETHToolbox>>).estimateTransactionFee({
+          ...txObject,
+          feeOption: params.feeOptionKey || FeeOption.Fast,
+          chain,
+        });
+      }
+      case Chain.Bitcoin:
+      case Chain.BitcoinCash:
+      case Chain.Dogecoin:
+      case Chain.Dash:
+      case Chain.Litecoin: {
+        return (toolbox as Awaited<ReturnType<typeof getUtxoToolbox>>).estimateTransactionFee(
+          params as CreateTransactionParams[Chain.Bitcoin],
+        );
+      }
+
+      case Chain.THORChain:
+      case Chain.Maya:
+      case Chain.Kujira:
+      case Chain.Cosmos: {
+        const { estimateTransactionFee } = await import("@swapkit/toolboxes/cosmos");
+        return estimateTransactionFee(params);
+      }
+
+      case Chain.Polkadot: {
+        return (
+          toolbox as Awaited<ReturnType<typeof getSubstrateToolbox<Chain.Polkadot>>>
+        ).estimateTransactionFee(params);
+      }
+
+      case Chain.Solana: {
+        return (toolbox as Awaited<ReturnType<typeof getSolanaToolbox>>).estimateTransactionFee(
+          params as CreateTransactionParams[Chain.Solana],
+        );
+      }
+
+      default:
+        return AssetValue.from({ chain });
+    }
+  };
+}
+
+type Toolboxes = {
+  [key in EVMChain]: Awaited<ReturnType<typeof getEvmToolbox>>;
+} & {
+  [key in UTXOChain]: Awaited<ReturnType<typeof getUtxoToolbox>>;
+} & {
+  [key in CosmosChain]: Awaited<ReturnType<typeof getCosmosToolbox>>;
+} & {
+  [key in SubstrateChain]: Awaited<ReturnType<typeof getSubstrateToolbox>>;
+} & {
+  [Chain.Radix]: Awaited<ReturnType<typeof RadixToolbox>>;
+  [Chain.Ripple]: Awaited<ReturnType<typeof getRippleToolbox>>;
+  [Chain.Solana]: Awaited<ReturnType<typeof getSolanaToolbox>>;
+};
+
+type ToolboxParams = { [key in EVMChain]: Parameters<typeof getEvmToolbox>[1] } & {
+  [key in UTXOChain]: undefined;
+} & {
+  [key in CosmosChain]: Parameters<typeof getCosmosToolbox>[1];
+} & {
+  [key in SubstrateChain]: Parameters<typeof getSubstrateToolbox>[1];
+} & {
+  [Chain.Radix]: Parameters<typeof RadixToolbox>[0];
+  [Chain.Ripple]: Parameters<typeof getRippleToolbox>[0];
+  [Chain.Solana]: Parameters<typeof getSolanaToolbox>[0];
+};
+
+type CreateTransactionParams = { [key in EVMChain]: EVMCreateTransactionParams } & {
+  [key in UTXOChain]: GenericCreateTransactionParams;
+} & {
+  [key in CosmosChain]: GenericCreateTransactionParams;
+} & {
+  [key in SubstrateChain]: GenericCreateTransactionParams;
+} & {
+  [Chain.Radix]: GenericCreateTransactionParams;
+  [Chain.Solana]: SolanaCreateTransactionParams;
+};
+
+export async function getToolbox<T extends keyof Toolboxes>(
+  chain: T,
+  params?: ToolboxParams[T],
+): Promise<Toolboxes[T]> {
+  switch (chain) {
+    case Chain.Arbitrum:
+    case Chain.Avalanche:
+    case Chain.Optimism:
+    case Chain.BinanceSmartChain:
+    case Chain.Base:
+    case Chain.Polygon:
+    case Chain.Ethereum: {
+      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
+      const evmToolbox = await getEvmToolbox(chain, params as Parameters<typeof getEvmToolbox>[1]);
+      return evmToolbox as Toolboxes[T];
+    }
+
+    case Chain.Litecoin:
+    case Chain.Dash:
+    case Chain.Dogecoin:
+    case Chain.BitcoinCash:
+    case Chain.Bitcoin: {
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+      const utxoToolbox = await getUtxoToolbox(
+        chain,
+        params as Parameters<typeof getUtxoToolbox>[1],
+      );
+      return utxoToolbox as Toolboxes[T];
+    }
+
+    case Chain.Cosmos:
+    case Chain.Kujira:
+    case Chain.Maya:
+    case Chain.THORChain: {
+      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
+      const cosmosToolbox = await getCosmosToolbox(
+        chain,
+        params as Parameters<typeof getCosmosToolbox>[1],
+      );
+
+      return cosmosToolbox as Toolboxes[T];
+    }
+
+    case Chain.Chainflip:
+    case Chain.Polkadot: {
+      const { getSubstrateToolbox } = await import("@swapkit/toolboxes/substrate");
+      const substrateToolbox = await getSubstrateToolbox(
+        chain,
+        params as Parameters<typeof getSubstrateToolbox>[1],
+      );
+      return substrateToolbox as Toolboxes[T];
+    }
+
+    case Chain.Radix: {
+      const { RadixToolbox } = await import("@swapkit/toolboxes/radix");
+      const radixToolbox = await RadixToolbox(params as Parameters<typeof RadixToolbox>[0]);
+      return radixToolbox as Toolboxes[T];
+    }
+
+    case Chain.Ripple: {
+      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
+      const rippleToolbox = await getRippleToolbox(
+        params as Parameters<typeof getRippleToolbox>[0],
+      );
+      return rippleToolbox as Toolboxes[T];
+    }
+
+    case Chain.Solana: {
+      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
+      const solanaToolbox = await getSolanaToolbox(
+        params as Parameters<typeof getSolanaToolbox>[0],
+      );
+      return solanaToolbox as Toolboxes[T];
+    }
+
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
+}

package/src/radix/index.ts

@@ -1,23 +1,20 @@
-import {
-  type FungibleResourcesCollectionItem,
+import type {
+  FungibleResourcesCollectionItem,
   GatewayApiClient,
-  type StateEntityDetailsVaultResponseItem,
-  type StateEntityFungiblesPageRequest,
-  type StateEntityFungiblesPageResponse,
+  StateEntityDetailsVaultResponseItem,
+  StateEntityFungiblesPageRequest,
+  StateEntityFungiblesPageResponse,
 } from "@radixdlt/babylon-gateway-api-sdk";
-import { RadixDappToolkit } from "@radixdlt/radix-dapp-toolkit";
-import { AssetValue, Chain, type SKConfigIntegrations } from "@swapkit/helpers";
+import { AssetValue, Chain, SKConfig, type SKConfigIntegrations } from "@swapkit/helpers";
 
-export type RadixWallets = {
-  [Chain.Radix]: Awaited<ReturnType<typeof RadixToolbox>>;
-};
+export type RadixWallet = Awaited<ReturnType<typeof RadixToolbox>>;
 
 type RadixGetBalanceParams = {
   address: string;
   networkApi: GatewayApiClient;
 };
 // Could not find anything sync in SDK, ask Radix team
-export function validateAddress(address: string) {
+export function radixValidateAddress(address: string) {
   return address.startsWith("account_rdx1") && address.length === 66;
 }
 
@@ -129,21 +126,23 @@ async function currentStateVersion(networkApi: GatewayApiClient) {
 
 export const RadixToolbox = async ({
   dappConfig,
-}: { dappConfig: SKConfigIntegrations["radix"] }) => {
+}: { dappConfig?: SKConfigIntegrations["radix"] } = {}) => {
+  const { RadixDappToolkit } = await import("@radixdlt/radix-dapp-toolkit");
+  const { GatewayApiClient } = await import("@radixdlt/babylon-gateway-api-sdk");
+  const config = dappConfig || SKConfig.get("integrations").radix;
+
   const radixToolkit = RadixDappToolkit({
-    ...dappConfig,
-    networkId: dappConfig.network?.networkId || 1,
+    ...config,
+    networkId: config.network?.networkId || 1,
   });
 
   const networkApi = GatewayApiClient.initialize(radixToolkit.gatewayApi.clientConfig);
 
   return {
-    networkApi,
+    getAddress: () => "",
     getBalance: getBalance({ networkApi }),
-    getAddress: () => {
-      return "";
-    },
-    validateAddress,
+    networkApi,
+    validateAddress: radixValidateAddress,
     signAndBroadcast: (() => {
       throw new Error("Not implemented");
     }) as (params: any) => Promise<string>,

package/src/ripple/index.ts

@@ -0,0 +1,199 @@
+import {
+  AssetValue,
+  BaseDecimal,
+  Chain,
+  type ChainSigner,
+  type GenericTransferParams,
+  SKConfig,
+  SwapKitError,
+  SwapKitNumber,
+} from "@swapkit/helpers";
+import type { Transaction } from "xrpl";
+import { Client, type Payment, Wallet, isValidAddress, xrpToDrops } from "xrpl";
+
+export type RippleWallet = Awaited<ReturnType<typeof getRippleToolbox>>;
+
+// Note: Ripple seeds generate a single address, no derivation path/index support.
+function createSigner(phrase: string): ChainSigner<Transaction, { tx_blob: string; hash: string }> {
+  const wallet = Wallet.fromMnemonic(phrase);
+  return {
+    // publicKey: wallet.publicKey,
+    // Address is sync, but interface requires async
+    getAddress: () => Promise.resolve(wallet.address),
+    // Signing is sync, but interface requires async
+    signTransaction: (tx: Transaction) => Promise.resolve(wallet.sign(tx as Transaction)), // Cast needed as Wallet.sign expects Transaction
+  };
+}
+
+export function rippleValidateAddress(address: string) {
+  return isValidAddress(address);
+}
+
+type RippleToolboxParams =
+  | { phrase: string }
+  | { signer: ChainSigner<Transaction, { tx_blob: string; hash: string }> }
+  | {};
+
+export const getRippleToolbox = async (params: RippleToolboxParams = {}) => {
+  const signer =
+    "signer" in params && params.signer
+      ? params.signer
+      : "phrase" in params && params.phrase
+        ? createSigner(params.phrase)
+        : undefined;
+
+  const rpcUrl = SKConfig.get("rpcUrls")[Chain.Ripple];
+  if (!rpcUrl) {
+    throw new SwapKitError({
+      errorKey: "toolbox_ripple_rpc_not_configured",
+      info: { chain: Chain.Ripple },
+    });
+  }
+
+  const client = new Client(rpcUrl);
+  await client.connect();
+
+  const getAddress = () => {
+    if (!signer) {
+      throw new SwapKitError({ errorKey: "toolbox_ripple_signer_not_found" });
+    }
+    return signer.getAddress();
+  };
+
+  const getBalance = async (address?: string) => {
+    const addr = address || (await getAddress());
+
+    try {
+      await client.connect();
+      const accountInfo = await client.request({
+        command: "account_info",
+        account: addr,
+      });
+
+      const balance = accountInfo.result.account_data.Balance;
+
+      return [
+        AssetValue.from({
+          chain: Chain.Ripple,
+          value: balance,
+          fromBaseDecimal: BaseDecimal[Chain.Ripple],
+        }),
+      ];
+    } catch (error) {
+      // empty account
+      if ((error as any).data.error_code === 19) {
+        return [
+          AssetValue.from({
+            chain: Chain.Ripple,
+            value: 0,
+          }),
+        ];
+      }
+      throw new SwapKitError("toolbox_ripple_get_balance_error", {
+        info: { address: addr, error },
+      });
+    }
+  };
+
+  const estimateTransactionFee = async () => {
+    const feeResponse = await client.request({ command: "fee" });
+    const feeDrops = feeResponse.result.drops.open_ledger_fee; // Fee in drops
+
+    return AssetValue.from({
+      chain: Chain.Ripple,
+      value: SwapKitNumber.fromBigInt(BigInt(feeDrops), BaseDecimal[Chain.Ripple]),
+    });
+  };
+
+  const createTransaction = async ({
+    assetValue,
+    recipient,
+    memo,
+    sender,
+  }: { assetValue: AssetValue; recipient: string; sender?: string; memo?: string }) => {
+    if (!rippleValidateAddress(recipient)) {
+      throw new SwapKitError({ errorKey: "core_transaction_invalid_recipient_address" });
+    }
+
+    const senderAddress = sender || (await getAddress());
+
+    if (!assetValue.isGasAsset || assetValue.chain !== Chain.Ripple) {
+      throw new SwapKitError({
+        errorKey: "toolbox_ripple_asset_not_supported",
+        info: { asset: assetValue.toString() },
+      });
+    }
+
+    const transaction: Payment = {
+      TransactionType: "Payment",
+      Account: senderAddress,
+      Amount: xrpToDrops(assetValue.getValue("string")),
+      Destination: recipient,
+    };
+
+    if (memo) {
+      transaction.Memos = [{ Memo: { MemoData: Buffer.from(memo).toString("hex") } }];
+    }
+
+    const preparedTx = await client.autofill(transaction);
+    return preparedTx;
+  };
+
+  const signTransaction = (tx: Transaction) => {
+    if (!signer) {
+      throw new SwapKitError({ errorKey: "toolbox_ripple_signer_not_found" });
+    }
+    return signer.signTransaction(tx);
+  };
+
+  const broadcastTransaction = async (signedTxHex: string) => {
+    const submitResult = await client.submitAndWait(signedTxHex);
+    // Cast result to any to bypass potential type mismatches in xrpl.js definitions
+    const result: any = submitResult.result;
+
+    // Check engine_result directly on result
+    if (result.engine_result === "tesSUCCESS" || result.engine_result === "terQUEUED") {
+      // Access hash from tx_json if available, otherwise fallback to result.hash
+      return result.tx_json?.hash || result.hash;
+    }
+
+    const message = result.engine_result_message || "Unknown error";
+    const code = result.engine_result || "Unknown code";
+
+    throw new SwapKitError({
+      errorKey: "toolbox_ripple_broadcast_error",
+      info: { chain: Chain.Ripple, message, code, result },
+      // Remove explicit message when using object format
+    });
+  };
+
+  const transfer = async (params: GenericTransferParams) => {
+    if (!signer) {
+      throw new SwapKitError({ errorKey: "toolbox_ripple_signer_not_found" });
+    }
+    const sender = await signer.getAddress();
+    const tx = await createTransaction({ ...params, sender });
+    const signedTx = await signTransaction(tx);
+    return broadcastTransaction(signedTx.tx_blob);
+  };
+
+  // Disconnect client on demand or handle elsewhere?
+  // For now, let's assume connection is managed outside or persists.
+  // const disconnect = () => client.disconnect();
+
+  return {
+    // Signer related
+    signer, // Expose the signer instance if created/provided
+    createSigner, // Expose the helper
+    // Core methods
+    getAddress,
+    validateAddress: rippleValidateAddress,
+    getBalance,
+    createTransaction,
+    signTransaction,
+    broadcastTransaction,
+    transfer,
+    estimateTransactionFee,
+    // disconnect, // Optional: expose disconnect
+  };
+};

package/src/solana/index.ts

@@ -1,6 +1,6 @@
 import type { PublicKey, SendOptions, Transaction, VersionedTransaction } from "@solana/web3.js";
-import { Chain } from "@swapkit/helpers";
-import type { SOLToolbox } from "./toolbox";
+import type { GenericCreateTransactionParams, GenericTransferParams } from "@swapkit/helpers";
+import type { getSolanaToolbox } from "./toolbox";
 
 type DisplayEncoding = "utf8" | "hex";
 
@@ -22,9 +22,7 @@ interface ConnectOpts {
 
 export * from "./toolbox";
 
-export type SolanaWallets = {
-  [Chain.Solana]: ReturnType<typeof SOLToolbox>;
-};
+export type SolanaWallet = Awaited<ReturnType<typeof getSolanaToolbox>>;
 
 export interface SolanaProvider {
   connect: (opts?: Partial<ConnectOpts>) => Promise<{ publicKey: PublicKey }>;
@@ -47,3 +45,11 @@ export interface SolanaProvider {
     transactions: T[],
   ) => Promise<T[]>;
 }
+
+export type SolanaCreateTransactionParams = Omit<GenericCreateTransactionParams, "feeRate"> & {
+  isProgramDerivedAddress?: boolean;
+};
+
+export type SolanaTransferParams = Omit<GenericTransferParams, "feeRate"> & {
+  isProgramDerivedAddress?: boolean;
+};