Configure SDK wallet providers

The SDK separates what (the Velora methods) from how it talks to the chain and the API. You wire two things:

A contract caller bridges between the SDK’s transactCall / signTypedDataCall / staticCall interface and your wallet library.
A fetcher bridges between the SDK’s FetcherFunction and your HTTP client.

Simple SDK builds both for you from a single options object. Full SDK and Partial SDKs take them as constructor arguments.

Contract callers

viem

import { createWalletClient, custom } from "viem";
import { mainnet } from "viem/chains";
import { constructViemContractCaller } from "@velora-dex/sdk";

const walletClient = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum!),
});
const [account] = await walletClient.getAddresses();

const contractCaller = constructViemContractCaller(walletClient, account);

Write methods resolve to a viem Hex (the transaction hash).

For sending the result of sdk.swap.buildTx via viem, the SDK exports txParamsToViemTxParams to cast all string-numbers to BigInt:

import { txParamsToViemTxParams } from "@velora-dex/sdk";

const tx = await sdk.swap.buildTx({
  /* ... */
});
const viemTx = txParamsToViemTxParams(tx);
const hash = await walletClient.sendTransaction({ ...viemTx, account });

ethers v5

import { ethers } from "ethers";
import { constructEthersContractCaller } from "@velora-dex/sdk";

const contractCaller = constructEthersContractCaller(
  {
    ethersProviderOrSigner: signer, // JsonRpcProvider, Wallet, or Web3Provider
    EthersContract: ethers.Contract,
  },
  account,
);

Write methods resolve to ethers.ContractTransaction. You can call .wait() directly on the result.

ethers v6

import { ethers } from "ethers";
import { constructEthersV6ContractCaller } from "@velora-dex/sdk";

const contractCaller = constructEthersV6ContractCaller(
  {
    ethersV6ProviderOrSigner: signer,
    EthersV6Contract: ethers.Contract,
  },
  account,
);

Write methods resolve to ethers v6’s ContractTransactionResponse.

web3.js

import Web3 from "web3";
import { constructWeb3ContractCaller } from "@velora-dex/sdk";

const web3 = new Web3(Web3.givenProvider);
const contractCaller = constructWeb3ContractCaller(web3, account);

Write methods resolve to web3’s PromiEvent<TransactionReceipt>. Listen on transactionHash for early notification:

const eventfulTx = await sdk.swap.approveToken(amount, USDC);
eventfulTx.once("transactionHash", (hash: string) =>
  console.log("tx sent:", hash),
);

Fetchers

axios

import axios from "axios";
import { constructAxiosFetcher } from "@velora-dex/sdk";

const fetcher = constructAxiosFetcher(axios);

fetch (Node 18+ and the browser)

import { constructFetchFetcher } from "@velora-dex/sdk";

const fetcher = constructFetchFetcher(fetch);

Custom fetcher

Any HTTP client works: implement FetcherFunction and pass it through. Useful for adding retries, logging, header injection, or wrapping an unusual transport.

import { constructSimpleSDK, type FetcherFunction } from "@velora-dex/sdk";

const customFetcher: FetcherFunction = async (options) => {
  // requestParams may include AbortSignal; honor it for cancellation
  const res = await myHttpClient(options.url, {
    method: options.method,
    headers: options.headers,
    body: options.method === "POST" ? options.data : undefined,
    signal: options.requestParams?.signal,
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.body;
};

const sdk = constructSimpleSDK({
  chainId: 1,
  fetcher: customFetcher,
});

For richer error semantics, throw a FetcherError and the SDK will re-throw it untouched so calling code can isFetcherError(err) and inspect the response.

wagmi recipe

If your app already uses wagmi, reuse the viem wallet client it manages:

import axios from "axios";
import { useConnection, useWalletClient } from "wagmi";
import {
  constructPartialSDK,
  constructAxiosFetcher,
  constructViemContractCaller,
  constructGetRate,
  constructBuildTx,
  constructApproveToken,
} from "@velora-dex/sdk";

const fetcher = constructAxiosFetcher(axios);

function useVeloraSDK() {
  const { address } = useConnection();
  const { data: walletClient } = useWalletClient();

  if (!walletClient || !address) return null;

  const contractCaller = constructViemContractCaller(walletClient, address);

  return constructPartialSDK(
    {
      chainId: walletClient.chain.id,
      fetcher,
      contractCaller,
    },
    constructGetRate,
    constructBuildTx,
    constructApproveToken,
  );
}

Memoize the result (with useMemo on the wallet client and address) to avoid rebuilding the SDK on every render.

Install covers peer dependencies for each wallet library.
Simple SDK: uses these callers and fetchers via a single options object.
Full SDK — takes the caller and fetcher you construct here.
Partial SDK, same wiring, smallest bundle.

​Contract callers

​viem

​ethers v5

​ethers v6

​web3.js

​Fetchers

​axios

​fetch (Node 18+ and the browser)

​Custom fetcher

​wagmi recipe

​Related pages