Executing Transactions

SwapDK provides a unified interface for creating and executing transactions across multiple blockchain networks. This guide explains how to perform transactions with the SwapDK library.

Two Approaches for Using SwapDK

You can use SwapDK in two ways:

1. Granular approach - Import only what you need from individual packages (recommended for frontend):

   import { SwapKit, evmWallet } from "@swapdk/sdk";

2. All-in-one approach - Import everything from the SDK (better for backend/Node.js):

   import { createSwapKit } from "@swapdk/sdk";

Basic Asset Transfer

The most common transaction is transferring assets from one address to another.

Granular Approach (Frontend Recommended)

import {
  AssetValue,
  Chain,
  FeeOption,
  SwapKit,
  keystoreWallet,
} from "@swapdk/sdk";

const swapDK = SwapKit({
  wallets: { ...keystoreWallet },
});

await swapDK.connectKeystore([Chain.Ethereum], "your secret phrase here");

const amount = AssetValue.from({
  chain: Chain.Ethereum,
  symbol: "ETH",
  value: "0.01",
});

async function transferAsset() {
  try {
    const txHash = await swapDK.transfer({
      assetValue: amount,
      recipient: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      memo: "Payment for services",
      feeOptionKey: FeeOption.Fast,
    });

    const txUrl = swapDK.getExplorerTxUrl({
      chain: Chain.Ethereum,
      txHash,
    });

    return { txHash, txUrl };
  } catch (error) {
    throw error;
  }
}

All-in-one Approach (Backend)

import { AssetValue, Chain, FeeOption, createSwapKit } from "@swapdk/sdk";

const swapDK = createSwapKit();

await swapDK.connectKeystore([Chain.Ethereum], "your secret phrase here");

const amount = AssetValue.from({
  chain: Chain.Ethereum,
  symbol: "ETH",
  value: "0.01",
});

async function transferAsset() {
  try {
    const txHash = await swapDK.transfer({
      assetValue: amount,
      recipient: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      feeOptionKey: FeeOption.Fast,
    });

    return txHash;
  } catch (error) {
    throw error;
  }
}

Transferring Different Asset Types

Transferring ERC20 Tokens

import { AssetValue, Chain, FeeOption, SwapKit, evmWallet } from "@swapdk/sdk";

const swapDK = SwapKit({
  wallets: { ...evmWallet },
});

await swapDK.connectEVMWallet([Chain.Ethereum]);

async function transferERC20() {
  const usdcAmount = AssetValue.from({
    chain: Chain.Ethereum,
    symbol: "USDC",
    ticker: "USDC",
    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    value: "10",
  });

  const txHash = await swapDK.transfer({
    assetValue: usdcAmount,
    recipient: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
    feeOptionKey: FeeOption.Average,
  });

  return txHash;
}

Transferring Bitcoin

import {
  AssetValue,
  Chain,
  FeeOption,
  SwapKit,
  keystoreWallet,
} from "@swapdk/sdk";

const swapDK = SwapKit({
  wallets: { ...keystoreWallet },
});

await swapDK.connectKeystore([Chain.Bitcoin], "your secret phrase here");

async function transferBitcoin() {
  const btcAmount = AssetValue.from({
    chain: Chain.Bitcoin,
    symbol: "BTC",
    value: "0.001",
  });

  const txHash = await swapDK.transfer({
    assetValue: btcAmount,
    recipient: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
    feeOptionKey: FeeOption.Fast,
    memo: "Bitcoin transfer example",
  });

  return txHash;
}

Transferring Cosmos Assets

import {
  AssetValue,
  Chain,
  FeeOption,
  SwapKit,
  keplrWallet,
} from "@swapdk/sdk";

const swapDK = SwapKit({
  wallets: { ...keplrWallet },
});

await swapDK.connectKeplr([Chain.Cosmos]);

async function transferCosmos() {
  const atomAmount = AssetValue.from({
    chain: Chain.Cosmos,
    symbol: "ATOM",
    value: "0.1",
  });

  const txHash = await swapDK.transfer({
    assetValue: atomAmount,
    recipient: "cosmos1abcd1234abcd1234abcd1234abcd1234abcd12",
    feeOptionKey: FeeOption.Average,
    memo: "Cosmos transfer example",
  });

  return txHash;
}

Using Toolboxes Directly for Transactions

For lower-level control, you can use the toolboxes directly instead of SwapDK’s high-level API:

EVM Toolbox Transfers

import { AssetValue, Chain, FeeOption, getEvmToolbox } from "@swapdk/sdk";
import { getProvider } from "@swapdk/helpers";
import { ethers } from "ethers";

async function directEVMTransfer() {
  const provider = await getProvider(Chain.Ethereum);
  const signer = new ethers.Wallet("your-private-key-here", provider);

  const ethToolbox = await getEvmToolbox(Chain.Ethereum, { signer });

  const amount = AssetValue.from({
    chain: Chain.Ethereum,
    symbol: "ETH",
    value: "0.01",
  });

  const txHash = await ethToolbox.transfer({
    assetValue: amount,
    recipient: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
    from: signer.address,
    feeOptionKey: FeeOption.Fast,
  });

  return txHash;
}

UTXO Toolbox Transfers

import { AssetValue, Chain, FeeOption, getUtxoToolbox } from "@swapdk/sdk";

async function directBitcoinTransfer() {
  const btcToolbox = await getUtxoToolbox(Chain.Bitcoin);

  const keys = await btcToolbox.createKeysForPath({
    phrase: "your twelve word mnemonic phrase here",
    derivationPath: "m/84'/0'/0'/0/0",
  });

  const fromAddress = btcToolbox.getAddressFromKeys(keys);

  async function signTransaction({
    builder,
    utxos,
  }: {
    builder: any;
    utxos: any[];
  }) {
    utxos.forEach((utxo, index) => {
      builder.sign(index, keys);
    });
    return builder.build();
  }

  const amount = AssetValue.from({
    chain: Chain.Bitcoin,
    symbol: "BTC",
    value: "0.001",
  });

  const txHash = await btcToolbox.transfer({
    assetValue: amount,
    recipient: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
    from: fromAddress,
    feeOptionKey: FeeOption.Fast,

    signTransaction,
  });

  return txHash;
}

Working with Contract Interactions

For EVM chains, you can interact with smart contracts using the EVM toolbox:

import { Chain, getEvmToolbox, erc20ABI } from "@swapdk/sdk";
import { getProvider } from "@swapdk/helpers";
import { ethers } from "ethers";

async function interactWithContract() {
  const provider = await getProvider(Chain.Ethereum);
  const signer = new ethers.Wallet("your-private-key-here", provider);

  const ethToolbox = await getEvmToolbox(Chain.Ethereum, { signer });

  const contractAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";

  const tokenName = await ethToolbox.call({
    contractAddress,
    abi: erc20ABI,
    funcName: "name",
  });

  const tokenSymbol = await ethToolbox.call({
    contractAddress,
    abi: erc20ABI,
    funcName: "symbol",
  });

  const tokenDecimals = await ethToolbox.call<number>({
    contractAddress,
    abi: erc20ABI,
    funcName: "decimals",
  });

  const balance = await ethToolbox.call<string>({
    contractAddress,
    abi: erc20ABI,
    funcName: "balanceOf",
    funcParams: [signer.address],
  });

  const formattedBalance = ethers.formatUnits(balance, tokenDecimals);

  return {
    name: tokenName,
    symbol: tokenSymbol,
    decimals: tokenDecimals,
    balance: formattedBalance,
  };
}