@swapkit/toolboxes 1.0.0-beta.0

package/src/evm/toolbox/avax.ts

@@ -0,0 +1,36 @@
+import { BaseDecimal, Chain, ChainId, ChainToExplorerUrl, type FeeOption } from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, Signer } from "ethers";
+
+import { type EVMTxBaseParams, estimateTransactionFee, getBalance } from "../index";
+
+import { EVMToolbox } from "./EVMToolbox";
+
+const getNetworkParams = () => ({
+  chainId: ChainId.AvalancheHex,
+  chainName: "Avalanche Network",
+  nativeCurrency: { name: "Avalanche", symbol: Chain.Avalanche, decimals: BaseDecimal.AVAX },
+  // Use external rpc URL so wallets don't throw warning to user
+  rpcUrls: ["https://api.avax.network/ext/bc/C/rpc"],
+  blockExplorerUrls: [ChainToExplorerUrl[Chain.Avalanche]],
+});
+
+export const AVAXToolbox = ({
+  provider,
+  signer,
+}: { signer?: Signer; provider: JsonRpcProvider | BrowserProvider }) => {
+  const evmToolbox = EVMToolbox({ provider, signer });
+  const chain = Chain.Avalanche;
+
+  return {
+    ...evmToolbox,
+    getNetworkParams,
+    estimateTransactionFee: (txObject: EVMTxBaseParams, feeOptionKey: FeeOption) =>
+      estimateTransactionFee(txObject, feeOptionKey, chain, provider),
+    getBalance: (
+      address: string,
+      potentialScamFilter = true,
+      overwriteProvider?: JsonRpcProvider | BrowserProvider,
+    ) =>
+      getBalance({ provider: overwriteProvider || provider, address, chain, potentialScamFilter }),
+  };
+};

package/src/evm/toolbox/base.ts

@@ -0,0 +1,42 @@
+import {
+  BaseDecimal,
+  Chain,
+  ChainId,
+  ChainToExplorerUrl,
+  type FeeOption,
+  SKConfig,
+} from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, Signer } from "ethers";
+
+import { type EVMTxBaseParams, estimateTransactionFee, getBalance } from "../index";
+
+import { EVMToolbox } from "./EVMToolbox";
+
+const getNetworkParams = () => ({
+  chainId: ChainId.BaseHex,
+  chainName: "Base Mainnet",
+  nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals: BaseDecimal.ETH },
+  rpcUrls: [SKConfig.get("rpcUrls")[Chain.Base]],
+  blockExplorerUrls: [ChainToExplorerUrl[Chain.Base]],
+});
+
+export const BASEToolbox = ({
+  provider,
+  signer,
+}: { signer?: Signer; provider: JsonRpcProvider | BrowserProvider }) => {
+  const evmToolbox = EVMToolbox({ provider, signer });
+  const chain = Chain.Base;
+
+  return {
+    ...evmToolbox,
+    getNetworkParams,
+    estimateTransactionFee: (txObject: EVMTxBaseParams, feeOptionKey: FeeOption) =>
+      estimateTransactionFee(txObject, feeOptionKey, chain, provider),
+    getBalance: async (
+      address: string,
+      potentialScamFilter = true,
+      overwriteProvider?: JsonRpcProvider | BrowserProvider,
+    ) =>
+      getBalance({ provider: overwriteProvider || provider, address, chain, potentialScamFilter }),
+  };
+};

package/src/evm/toolbox/bsc.ts

@@ -0,0 +1,34 @@
+import { BaseDecimal, Chain, ChainId, ChainToExplorerUrl, type FeeOption } from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, Signer } from "ethers";
+
+import { type EVMTxBaseParams, estimateTransactionFee, getBalance } from "../index";
+import { EVMToolbox } from "./EVMToolbox";
+
+const getNetworkParams = () => ({
+  chainId: ChainId.BinanceSmartChainHex,
+  chainName: "BNB Chain",
+  nativeCurrency: { name: "Binance Coin", symbol: "BNB", decimals: BaseDecimal.BSC },
+  rpcUrls: ["https://bsc-dataseed.binance.org"],
+  blockExplorerUrls: [ChainToExplorerUrl[Chain.BinanceSmartChain]],
+});
+
+export const BSCToolbox = ({
+  provider,
+  signer,
+}: { signer?: Signer; provider: JsonRpcProvider | BrowserProvider }) => {
+  const evmToolbox = EVMToolbox({ provider, signer, isEIP1559Compatible: false });
+  const chain = Chain.BinanceSmartChain;
+
+  return {
+    ...evmToolbox,
+    getNetworkParams,
+    estimateTransactionFee: (txObject: EVMTxBaseParams, feeOptionKey: FeeOption) =>
+      estimateTransactionFee(txObject, feeOptionKey, chain, provider, false),
+    getBalance: (
+      address: string,
+      potentialScamFilter = true,
+      overwriteProvider?: JsonRpcProvider | BrowserProvider,
+    ) =>
+      getBalance({ provider: overwriteProvider || provider, address, chain, potentialScamFilter }),
+  };
+};

package/src/evm/toolbox/eth.ts

@@ -0,0 +1,44 @@
+import { Chain, FeeOption } from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, JsonRpcSigner, Signer } from "ethers";
+
+import { type EVMTxBaseParams, estimateTransactionFee, getBalance } from "../index";
+
+import { multicallAbi } from "../contracts/eth/multicall";
+import { EVMToolbox } from "./EVMToolbox";
+
+export const ETHToolbox = ({
+  signer,
+  provider,
+}: { signer?: Signer | JsonRpcSigner; provider: JsonRpcProvider | BrowserProvider }) => {
+  const evmToolbox = EVMToolbox({ provider, signer });
+  const chain = Chain.Ethereum;
+
+  async function multicall(
+    callTuples: { address: string; data: string }[],
+    multicallAddress = "0x5ba1e12693dc8f9c48aad8770482f4739beed696",
+    funcName = "aggregate",
+    feeOptionKey: FeeOption = FeeOption.Fast,
+  ) {
+    const txObject = await evmToolbox.createContractTxObject({
+      contractAddress: multicallAddress,
+      abi: multicallAbi,
+      funcName,
+      funcParams: [callTuples],
+    });
+
+    return evmToolbox.sendTransaction(txObject, feeOptionKey);
+  }
+
+  return {
+    ...evmToolbox,
+    multicall,
+    estimateTransactionFee: (txObject: EVMTxBaseParams, feeOptionKey?: FeeOption) =>
+      estimateTransactionFee(txObject, feeOptionKey, chain, provider),
+    getBalance: (
+      address: string,
+      potentialScamFilter = true,
+      overwriteProvider?: JsonRpcProvider | BrowserProvider,
+    ) =>
+      getBalance({ provider: overwriteProvider || provider, address, chain, potentialScamFilter }),
+  };
+};

package/src/evm/toolbox/getToolboxByChain.ts

@@ -0,0 +1,42 @@
+import { Chain } from "@swapkit/helpers";
+
+import { ARBToolbox } from "./arb";
+import { AVAXToolbox } from "./avax";
+import { BASEToolbox } from "./base";
+import { BSCToolbox } from "./bsc";
+import { ETHToolbox } from "./eth";
+import { MATICToolbox } from "./matic";
+import { OPToolbox } from "./op";
+
+type ToolboxType = {
+  ARB: typeof ARBToolbox;
+  AVAX: typeof AVAXToolbox;
+  BASE: typeof BASEToolbox;
+  BSC: typeof BSCToolbox;
+  ETH: typeof ETHToolbox;
+  MATIC: typeof MATICToolbox;
+  OP: typeof OPToolbox;
+};
+
+export const getToolboxByChain = <T extends keyof ToolboxType>(chain: T): ToolboxType[T] => {
+  switch (chain) {
+    case Chain.Avalanche:
+      return AVAXToolbox as ToolboxType[T];
+    case Chain.Arbitrum:
+      return ARBToolbox as ToolboxType[T];
+    case Chain.Base:
+      return BASEToolbox as ToolboxType[T];
+    case Chain.Optimism:
+      return OPToolbox as ToolboxType[T];
+    case Chain.Polygon:
+      return MATICToolbox as ToolboxType[T];
+    case Chain.BinanceSmartChain:
+      return BSCToolbox as ToolboxType[T];
+    case Chain.Ethereum:
+      return ETHToolbox as ToolboxType[T];
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
+};
+
+export { evmValidateAddress } from "./EVMToolbox";

package/src/evm/toolbox/matic.ts

@@ -0,0 +1,42 @@
+import {
+  BaseDecimal,
+  Chain,
+  ChainId,
+  ChainToExplorerUrl,
+  type FeeOption,
+  SKConfig,
+} from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, Signer } from "ethers";
+
+import { type EVMTxBaseParams, estimateTransactionFee, getBalance } from "../index";
+
+import { EVMToolbox } from "./EVMToolbox";
+
+const getNetworkParams = () => ({
+  chainId: ChainId.PolygonHex,
+  chainName: "Polygon Mainnet",
+  nativeCurrency: { name: "Polygon", symbol: Chain.Polygon, decimals: BaseDecimal.MATIC },
+  rpcUrls: [SKConfig.get("rpcUrls")[Chain.Polygon]],
+  blockExplorerUrls: [ChainToExplorerUrl[Chain.Polygon]],
+});
+
+export const MATICToolbox = ({
+  provider,
+  signer,
+}: { signer?: Signer; provider: JsonRpcProvider | BrowserProvider }) => {
+  const evmToolbox = EVMToolbox({ provider, signer });
+  const chain = Chain.Polygon;
+
+  return {
+    ...evmToolbox,
+    getNetworkParams,
+    estimateTransactionFee: (txObject: EVMTxBaseParams, feeOptionKey: FeeOption) =>
+      estimateTransactionFee(txObject, feeOptionKey, chain, provider),
+    getBalance: (
+      address: string,
+      potentialScamFilter = true,
+      overwriteProvider?: JsonRpcProvider | BrowserProvider,
+    ) =>
+      getBalance({ provider: overwriteProvider || provider, address, chain, potentialScamFilter }),
+  };
+};

package/src/evm/toolbox/op.ts

@@ -0,0 +1,163 @@
+import {
+  BaseDecimal,
+  Chain,
+  ChainId,
+  ChainToExplorerUrl,
+  FeeOption,
+  SKConfig,
+} from "@swapkit/helpers";
+import type { BrowserProvider, JsonRpcProvider, Signer, TransactionRequest } from "ethers";
+import { Contract, Transaction } from "ethers";
+
+import { gasOracleAbi } from "../contracts/op/gasOracle";
+import { getBalance } from "../index";
+
+import { EVMToolbox } from "./EVMToolbox";
+
+const GAS_PRICE_ORACLE_ADDRESS = "0x420000000000000000000000000000000000000f";
+
+export const connectGasPriceOracle = (provider: JsonRpcProvider | BrowserProvider) => {
+  return new Contract(GAS_PRICE_ORACLE_ADDRESS, gasOracleAbi, provider);
+};
+
+export const getL1GasPrice = (provider: JsonRpcProvider | BrowserProvider) => {
+  const gasPriceOracle = connectGasPriceOracle(provider);
+
+  if (gasPriceOracle && "l1BaseFee" in gasPriceOracle) {
+    return gasPriceOracle?.l1BaseFee() as unknown as bigint;
+  }
+
+  return undefined;
+};
+
+const _serializeTx = async (
+  provider: JsonRpcProvider | BrowserProvider,
+  { data, from, to, gasPrice, type, gasLimit, nonce }: TransactionRequest,
+) => {
+  if (!to) throw new Error("Missing to address");
+
+  return Transaction.from({
+    data,
+    to: to as string,
+    gasPrice,
+    type,
+    gasLimit,
+    nonce: nonce ? nonce : from ? await provider.getTransactionCount(from) : 0,
+  }).serialized;
+};
+
+export const estimateL1GasCost = async (
+  provider: JsonRpcProvider | BrowserProvider,
+  tx: TransactionRequest,
+) => {
+  const gasPriceOracle = await connectGasPriceOracle(provider);
+  const serializedTx = await _serializeTx(provider, tx);
+
+  if (gasPriceOracle && "getL1Fee" in gasPriceOracle) {
+    return gasPriceOracle.getL1Fee(serializedTx);
+  }
+};
+
+export const estimateL2GasCost = async (
+  provider: JsonRpcProvider | BrowserProvider,
+  tx: TransactionRequest,
+) => {
+  const l2GasPrice = await provider.send("eth_gasPrice", []);
+  const l2GasCost = await provider.estimateGas(tx);
+  return l2GasPrice.mul(l2GasCost);
+};
+
+export const estimateTotalGasCost = async (
+  provider: JsonRpcProvider | BrowserProvider,
+  tx: TransactionRequest,
+) => {
+  const l1GasCost = await estimateL1GasCost(provider, tx);
+  const l2GasCost = await estimateL2GasCost(provider, tx);
+  return l1GasCost.add(l2GasCost);
+};
+
+export const estimateL1Gas = async (
+  provider: JsonRpcProvider | BrowserProvider,
+  tx: TransactionRequest,
+) => {
+  const gasPriceOracle = connectGasPriceOracle(provider);
+  const serializedTx = await _serializeTx(provider, tx);
+
+  if (gasPriceOracle && "getL1GasUsed" in gasPriceOracle) {
+    return gasPriceOracle.getL1GasUsed(serializedTx);
+  }
+};
+
+const getNetworkParams = () => ({
+  chainId: ChainId.OptimismHex,
+  chainName: "Optimism",
+  nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals: BaseDecimal.ETH },
+  rpcUrls: [SKConfig.get("rpcUrls")[Chain.Optimism]],
+  blockExplorerUrls: [ChainToExplorerUrl[Chain.Optimism]],
+});
+
+const estimateGasPrices = async (provider: JsonRpcProvider | BrowserProvider) => {
+  try {
+    const { maxFeePerGas, maxPriorityFeePerGas, gasPrice } = await provider.getFeeData();
+    const l1GasPrice = await getL1GasPrice(provider);
+    const price = gasPrice as bigint;
+
+    if (!(maxFeePerGas && maxPriorityFeePerGas)) {
+      throw new Error("No fee data available");
+    }
+
+    return {
+      [FeeOption.Average]: {
+        l1GasPrice,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+      },
+      [FeeOption.Fast]: {
+        l1GasPrice: ((l1GasPrice || 0n) * 15n) / 10n,
+        gasPrice: (price * 15n) / 10n,
+        maxFeePerGas,
+        maxPriorityFeePerGas: (maxPriorityFeePerGas * 15n) / 10n,
+      },
+      [FeeOption.Fastest]: {
+        l1GasPrice: (l1GasPrice || 0n) * 2n,
+        gasPrice: price * 2n,
+        maxFeePerGas,
+        maxPriorityFeePerGas: maxPriorityFeePerGas * 2n,
+      },
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
+    );
+  }
+};
+
+export const OPToolbox = ({
+  provider,
+  signer,
+}: { signer?: Signer; provider: JsonRpcProvider | BrowserProvider }) => {
+  const evmToolbox = EVMToolbox({ provider, signer });
+
+  return {
+    ...evmToolbox,
+    estimateTotalGasCost: (tx: TransactionRequest) => estimateTotalGasCost(provider, tx),
+    estimateL1GasCost: (tx: TransactionRequest) => estimateL1GasCost(provider, tx),
+    estimateL2GasCost: (tx: TransactionRequest) => estimateL2GasCost(provider, tx),
+    getL1GasPrice: () => getL1GasPrice(provider),
+    estimateL1Gas: (tx: TransactionRequest) => estimateL1Gas(provider, tx),
+    getNetworkParams,
+    estimateGasPrices: () => estimateGasPrices(provider),
+    getBalance: (
+      address: string,
+      potentialScamFilter = true,
+      overwriteProvider?: JsonRpcProvider | BrowserProvider,
+    ) =>
+      getBalance({
+        provider: overwriteProvider || provider,
+        address,
+        chain: Chain.Optimism,
+        potentialScamFilter,
+      }),
+  };
+};

package/src/evm/types.ts

@@ -0,0 +1,118 @@
+import type { AssetValue, FeeOption, WalletTxParams } from "@swapkit/helpers";
+import type { BigNumberish, JsonFragment, Transaction } from "ethers";
+
+import type {
+  ARBToolbox,
+  AVAXToolbox,
+  BASEToolbox,
+  BSCToolbox,
+  ETHToolbox,
+  MATICToolbox,
+  OPToolbox,
+} from "./index";
+import type { getProvider } from "./provider";
+
+export enum EthNetwork {
+  Test = "goerli",
+  Main = "homestead",
+}
+
+export type ApproveParams = {
+  assetAddress: string;
+  spenderAddress: string;
+  feeOptionKey?: FeeOption;
+  amount?: BigNumberish;
+  from: string;
+  // Optional fallback in case estimation for gas limit fails
+  gasLimitFallback?: BigNumberish;
+  nonce?: number;
+};
+
+export type ApprovedParams = {
+  assetAddress: string;
+  spenderAddress: string;
+  from: string;
+};
+
+export type IsApprovedParams = ApprovedParams & {
+  amount?: BigNumberish;
+};
+
+export type CallParams = {
+  callProvider?: ReturnType<typeof getProvider>;
+  contractAddress: string;
+  abi: readonly JsonFragment[];
+  funcName: string;
+  funcParams?: unknown[];
+  txOverrides?: Partial<Transaction>;
+  feeOption?: FeeOption;
+};
+
+export type EstimateCallParams = Pick<
+  CallParams,
+  "contractAddress" | "abi" | "funcName" | "funcParams" | "txOverrides"
+>;
+
+export type TransferParams = WalletTxParams & {
+  gasLimit?: bigint;
+  gasPrice?: bigint;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
+  data?: string;
+  from: string;
+  nonce?: number;
+  assetValue: AssetValue;
+};
+
+export type EVMToolboxType = ReturnType<
+  | typeof ARBToolbox
+  | typeof AVAXToolbox
+  | typeof BASEToolbox
+  | typeof BSCToolbox
+  | typeof ETHToolbox
+  | typeof MATICToolbox
+  | typeof OPToolbox
+>;
+
+export type EVMMaxSendableAmountsParams = {
+  from: string;
+  toolbox: EVMToolboxType;
+  assetValue: AssetValue;
+  feeOptionKey?: FeeOption;
+  memo?: string;
+  abi?: readonly JsonFragment[];
+  funcName?: string;
+  contractAddress?: string;
+  funcParams?: unknown[];
+  txOverrides?: Partial<Transaction>;
+};
+
+export type EVMTxBaseParams<T = bigint> = {
+  to?: string;
+  from?: string;
+  nonce?: number;
+  gasLimit?: T;
+  data?: string;
+  value?: T;
+  chainId?: T;
+};
+
+export type EIP1559TxParams<T = bigint> = EVMTxBaseParams<T> & {
+  type?: number;
+  maxFeePerGas?: T;
+  maxPriorityFeePerGas?: T;
+};
+
+export type LegacyEVMTxParams<T = bigint> = EVMTxBaseParams<T> & {
+  gasPrice?: T;
+};
+
+export type EVMTxParams = EIP1559TxParams | LegacyEVMTxParams;
+
+export type NonETHToolbox =
+  | ReturnType<typeof ARBToolbox>
+  | ReturnType<typeof AVAXToolbox>
+  | ReturnType<typeof BSCToolbox>
+  | ReturnType<typeof MATICToolbox>
+  | ReturnType<typeof OPToolbox>
+  | ReturnType<typeof BASEToolbox>;

package/src/radix/index.ts

@@ -0,0 +1,151 @@
+import {
+  type FungibleResourcesCollectionItem,
+  GatewayApiClient,
+  type StateEntityDetailsVaultResponseItem,
+  type StateEntityFungiblesPageRequest,
+  type StateEntityFungiblesPageResponse,
+} from "@radixdlt/babylon-gateway-api-sdk";
+import { RadixDappToolkit } from "@radixdlt/radix-dapp-toolkit";
+import { AssetValue, Chain, type SKConfigIntegrations } from "@swapkit/helpers";
+
+export type RadixWallets = {
+  [Chain.Radix]: 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) {
+  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 radixToolkit = RadixDappToolkit({
+    ...dappConfig,
+    networkId: dappConfig.network?.networkId || 1,
+  });
+
+  const networkApi = GatewayApiClient.initialize(radixToolkit.gatewayApi.clientConfig);
+
+  return {
+    networkApi,
+    getBalance: getBalance({ networkApi }),
+    getAddress: () => {
+      return "";
+    },
+    validateAddress,
+    signAndBroadcast: (() => {
+      throw new Error("Not implemented");
+    }) as (params: any) => Promise<string>,
+  };
+};