@swapkit/toolboxes 4.0.0-beta.50 → 4.0.0-beta.52

package/src/radix/index.ts

@@ -1,156 +0,0 @@
-import type {
-  FungibleResourcesCollectionItem,
-  GatewayApiClient,
-  StateEntityDetailsVaultResponseItem,
-  StateEntityFungiblesPageRequest,
-  StateEntityFungiblesPageResponse,
-} from "@radixdlt/babylon-gateway-api-sdk";
-import {
-  AssetValue,
-  Chain,
-  SKConfig,
-  type SKConfigIntegrations,
-  SwapKitError,
-} from "@swapkit/helpers";
-
-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 radixValidateAddress(address: string) {
-  return address.startsWith("account_rdx1") && address.length === 66;
-}
-
-function getBalance({ networkApi }: { networkApi: GatewayApiClient }) {
-  return async function getBalance(address: string) {
-    const fungibleResources = await fetchFungibleResources({ address, networkApi });
-    const fungibleBalances = convertResourcesToBalances({
-      resources: fungibleResources,
-      networkApi,
-    });
-    return fungibleBalances;
-  };
-}
-
-async function fetchFungibleResources({
-  address,
-  networkApi,
-}: RadixGetBalanceParams): Promise<FungibleResourcesCollectionItem[]> {
-  let hasNextPage = true;
-  let nextCursor: string | undefined;
-  let fungibleResources: FungibleResourcesCollectionItem[] = [];
-  const stateVersion = await currentStateVersion(networkApi);
-  while (hasNextPage) {
-    const stateEntityFungiblesPageRequest: StateEntityFungiblesPageRequest = {
-      address: address,
-      limit_per_page: 100,
-      cursor: nextCursor,
-      at_ledger_state: {
-        state_version: stateVersion,
-      },
-    };
-
-    const stateEntityFungiblesPageResponse: StateEntityFungiblesPageResponse =
-      await networkApi.state.innerClient.entityFungiblesPage({
-        stateEntityFungiblesPageRequest: stateEntityFungiblesPageRequest,
-      });
-
-    fungibleResources = fungibleResources.concat(stateEntityFungiblesPageResponse.items);
-    if (stateEntityFungiblesPageResponse.next_cursor) {
-      nextCursor = stateEntityFungiblesPageResponse.next_cursor;
-    } else {
-      hasNextPage = false;
-    }
-  }
-  return fungibleResources;
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
-async function convertResourcesToBalances({
-  resources,
-  networkApi,
-}: {
-  resources: FungibleResourcesCollectionItem[]; //| NonFungibleResourcesCollectionItem[];
-  networkApi: GatewayApiClient;
-}): Promise<AssetValue[]> {
-  const balances: AssetValue[] = [];
-  const BATCH_SIZE = 50;
-
-  // Split resources into batches of up to 50 items
-  const resourceBatches: FungibleResourcesCollectionItem[][] = [];
-  for (let i = 0; i < resources.length; i += BATCH_SIZE) {
-    resourceBatches.push(resources.slice(i, i + BATCH_SIZE));
-  }
-
-  for (const batch of resourceBatches) {
-    const addresses = batch.map((item) => item.resource_address);
-    const response: StateEntityDetailsVaultResponseItem[] =
-      await networkApi.state.getEntityDetailsVaultAggregated(addresses);
-
-    const divisibilities = new Map<string, { decimals: number; symbol: string }>();
-
-    for (const result of response) {
-      if (result.details !== undefined) {
-        const metaDataSymbol = result.metadata?.items.find((item) => item.key === "symbol");
-        const symbol =
-          metaDataSymbol?.value.typed.type === "String" ? metaDataSymbol.value.typed.value : "?";
-
-        if (result.details.type === "FungibleResource") {
-          divisibilities.set(result.address, {
-            decimals: result.details.divisibility,
-            symbol,
-          });
-        }
-      }
-    }
-
-    for (const item of batch) {
-      if (item.aggregation_level === "Global") {
-        const assetInfo = divisibilities.get(item.resource_address) || { decimals: 0, symbol: "?" };
-
-        const balance = AssetValue.from({
-          asset:
-            assetInfo.symbol !== Chain.Radix
-              ? `${Chain.Radix}.${assetInfo.symbol}-${item.resource_address}`
-              : "XRD.XRD",
-          value: item.amount,
-        });
-        balances.push(balance);
-      }
-    }
-  }
-
-  return balances;
-}
-
-async function currentStateVersion(networkApi: GatewayApiClient) {
-  return networkApi.status.getCurrent().then((status) => status.ledger_state.state_version);
-}
-
-export const RadixToolbox = async ({
-  dappConfig,
-}: { 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({
-    ...config,
-    networkId: config.network?.networkId || 1,
-  });
-
-  const networkApi = GatewayApiClient.initialize(radixToolkit.gatewayApi.clientConfig);
-
-  return {
-    getAddress: () => "",
-    getBalance: getBalance({ networkApi }),
-    networkApi,
-    validateAddress: radixValidateAddress,
-    signAndBroadcast: (() => {
-      throw new SwapKitError("toolbox_radix_method_not_supported", { method: "signAndBroadcast" });
-    }) as (params: any) => Promise<string>,
-  };
-};

package/src/ripple/index.ts

@@ -1,192 +0,0 @@
-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>>;
-
-export { hashes, type Transaction } from "xrpl";
-
-const RIPPLE_ERROR_CODES = {
-  ACCOUNT_NOT_FOUND: 19,
-} as const;
-
-// 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 {
-      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 === RIPPLE_ERROR_CODES.ACCOUNT_NOT_FOUND) {
-        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);
-    const result = submitResult.result;
-
-    if (result.validated) {
-      return result.hash;
-    }
-
-    throw new SwapKitError({
-      errorKey: "toolbox_ripple_broadcast_error",
-      info: { chain: Chain.Ripple },
-    });
-  };
-
-  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);
-  };
-
-  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,
-  };
-};

package/src/solana/index.ts

@@ -1,55 +0,0 @@
-import type { PublicKey, SendOptions, Transaction, VersionedTransaction } from "@solana/web3.js";
-import type { GenericCreateTransactionParams, GenericTransferParams } from "@swapkit/helpers";
-import type { getSolanaToolbox } from "./toolbox";
-
-type DisplayEncoding = "utf8" | "hex";
-
-type PhantomEvent = "connect" | "disconnect" | "accountChanged";
-
-type PhantomRequestMethod =
-  | "connect"
-  | "disconnect"
-  | "signAndSendTransaction"
-  | "signAndSendTransactionV0"
-  | "signAndSendTransactionV0WithLookupTable"
-  | "signTransaction"
-  | "signAllTransactions"
-  | "signMessage";
-
-interface ConnectOpts {
-  onlyIfTrusted: boolean;
-}
-
-export * from "./toolbox";
-
-export type SolanaWallet = Awaited<ReturnType<typeof getSolanaToolbox>>;
-
-export interface SolanaProvider {
-  connect: (opts?: Partial<ConnectOpts>) => Promise<{ publicKey: PublicKey }>;
-  disconnect: () => Promise<void>;
-  getAddress: () => Promise<string>;
-  isConnected: boolean | null;
-  isPhantom: boolean;
-  on: (event: PhantomEvent, handler: (args: any) => void) => void;
-  publicKey: PublicKey | null;
-  request: (method: PhantomRequestMethod, params: any) => Promise<unknown>;
-  signMessage: (message: Uint8Array | string, display?: DisplayEncoding) => Promise<any>;
-  signAndSendTransaction: (
-    transaction: Transaction | VersionedTransaction,
-    opts?: SendOptions,
-  ) => Promise<{ signature: string; publicKey: PublicKey }>;
-  signTransaction: <T extends Transaction | VersionedTransaction = Transaction>(
-    transaction: T,
-  ) => Promise<T>;
-  signAllTransactions: <T extends Transaction | VersionedTransaction = Transaction>(
-    transactions: T[],
-  ) => Promise<T[]>;
-}
-
-export type SolanaCreateTransactionParams = Omit<GenericCreateTransactionParams, "feeRate"> & {
-  isProgramDerivedAddress?: boolean;
-};
-
-export type SolanaTransferParams = Omit<GenericTransferParams, "feeRate"> & {
-  isProgramDerivedAddress?: boolean;
-};