@uswap/toolboxes 4.3.6

package/src/radix/index.ts

@@ -0,0 +1,132 @@
+import type {
+  FungibleResourcesCollectionItem,
+  GatewayApiClient,
+  StateEntityDetailsVaultResponseItem,
+  StateEntityFungiblesPageRequest,
+  StateEntityFungiblesPageResponse,
+} from "@radixdlt/babylon-gateway-api-sdk";
+import { AssetValue, Chain, SKConfig, type SKConfigIntegrations, SwapKitError } from "@uswap/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({ networkApi, resources: fungibleResources });
+    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,
+      at_ledger_state: { state_version: stateVersion },
+      cursor: nextCursor,
+      limit_per_page: 100,
+    };
+
+    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;
+}
+
+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;
+}
+
+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,
+    signAndBroadcast: (() => {
+      throw new SwapKitError("toolbox_radix_method_not_supported", { method: "signAndBroadcast" });
+    }) as (params: any) => Promise<string>,
+    validateAddress: radixValidateAddress,
+  };
+};

package/src/ripple/index.ts

@@ -0,0 +1,179 @@
+import {
+  AssetValue,
+  Chain,
+  type ChainSigner,
+  type GenericTransferParams,
+  getChainConfig,
+  getRPCUrl,
+  SwapKitError,
+  SwapKitNumber,
+} from "@uswap/helpers";
+import type { Transaction } from "xrpl";
+import { Client, isValidAddress, type Payment, Wallet, 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 = await getRPCUrl(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());
+    const { baseDecimal } = getChainConfig(Chain.Ripple);
+
+    try {
+      const accountInfo = await client.request({ account: addr, command: "account_info" });
+
+      const balance = accountInfo.result.account_data.Balance;
+
+      return [AssetValue.from({ chain: Chain.Ripple, fromBaseDecimal: baseDecimal, value: balance })];
+    } 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
+
+    const { baseDecimal } = getChainConfig(Chain.Ripple);
+
+    return AssetValue.from({
+      chain: Chain.Ripple,
+      fromBaseDecimal: baseDecimal,
+      value: SwapKitNumber.fromBigInt(BigInt(feeDrops), baseDecimal),
+    });
+  };
+
+  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 = {
+      Account: senderAddress,
+      Amount: xrpToDrops(assetValue.getValue("string")),
+      Destination: recipient,
+      TransactionType: "Payment",
+    };
+
+    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 {
+    broadcastTransaction,
+    createSigner, // Expose the helper
+    createTransaction,
+    disconnect,
+    estimateTransactionFee,
+    // Core methods
+    getAddress,
+    getBalance,
+    // Signer related
+    signer, // Expose the signer instance if created/provided
+    signTransaction,
+    transfer,
+    validateAddress: rippleValidateAddress,
+  };
+};

package/src/solana/index.ts

@@ -0,0 +1,36 @@
+import type { PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+import type { GenericCreateTransactionParams, GenericTransferParams } from "@uswap/helpers";
+import type { getSolanaToolbox } from "./toolbox";
+
+// type DisplayEncoding = "utf8" | "hex";
+
+// 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>;
+  publicKey: PublicKey | null;
+  signTransaction: <T extends Transaction | VersionedTransaction = Transaction>(transaction: T) => Promise<T>;
+}
+
+export type SolanaCreateTransactionParams = Omit<GenericCreateTransactionParams, "feeRate"> & {
+  isProgramDerivedAddress?: boolean;
+};
+
+export type SolanaTransferParams = Omit<GenericTransferParams, "feeRate"> & { isProgramDerivedAddress?: boolean };