@velora-dex/sdk 8.0.0

package/src/examples/simple.ts

@@ -0,0 +1,44 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers, Wallet } from 'ethersV5';
+import {
+  constructSimpleSDK,
+  ContractMethod,
+  SwapSide,
+  SimpleSDKProviderOptions,
+} from '..';
+
+const provider = ethers.getDefaultProvider(1);
+const signer = Wallet.createRandom().connect(provider);
+// only methods that fetch from API
+const simpleFetchOnlySDK = constructSimpleSDK({ chainId: 1, axios });
+
+const DAI_TOKEN = '0x6b175474e89094c44da98b954eedeac495271d0f';
+const USDC_TOKEN = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+
+const account = signer.address;
+
+// type Promise<OptimalRate>
+const rateRes = simpleFetchOnlySDK.swap.getRate({
+  srcToken: DAI_TOKEN,
+  destToken: USDC_TOKEN,
+  amount: '1000000000000',
+  userAddress: account,
+  side: SwapSide.SELL,
+});
+
+const providerOptions: SimpleSDKProviderOptions = {
+  ethersProviderOrSigner: signer,
+  EthersContract: ethers.Contract,
+  account,
+};
+
+const SDKwithApprove = constructSimpleSDK(
+  { chainId: 1, axios },
+  providerOptions
+);
+
+const approveTxHash = SDKwithApprove.swap.approveToken(
+  '1000000000000',
+  DAI_TOKEN
+);

package/src/examples/simpleQuote.ts

@@ -0,0 +1,98 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers } from 'ethersV5';
+import { constructSimpleSDK } from '..';
+
+const DAI_TOKEN = '0x6b175474e89094c44da98b954eedeac495271d0f';
+const USDC_TOKEN = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+
+async function allQuote() {
+  // @ts-expect-error assume window.ethereum is available
+  const ethersProvider = new ethers.providers.Web3Provider(window.ethereum);
+
+  const accounts = await ethersProvider.listAccounts();
+  const account = accounts[0]!;
+  const signer = ethersProvider.getSigner(account);
+
+  const simpleSDK = constructSimpleSDK(
+    { chainId: 1, axios },
+    {
+      ethersProviderOrSigner: signer,
+      EthersContract: ethers.Contract,
+      account,
+    }
+  );
+
+  const amount = '1000000000000'; // wei
+
+  const quote = await simpleSDK.quote.getQuote({
+    srcToken: DAI_TOKEN,
+    destToken: USDC_TOKEN,
+    amount,
+    userAddress: account,
+    srcDecimals: 18,
+    destDecimals: 18,
+    mode: 'all', // Delta quote if possible, with fallback to Market price
+    side: 'SELL',
+    // partner: "..." // if available
+  });
+
+  if ('delta' in quote) {
+    const deltaPrice = quote.delta;
+
+    const DeltaContract = await simpleSDK.delta.getDeltaContract();
+
+    // or sign a Permit1 or Permit2 TransferFrom for DeltaContract
+    const approveTxHash = await simpleSDK.delta.approveTokenForDelta(
+      amount,
+      DAI_TOKEN
+    );
+
+    const slippagePercent = 0.5;
+    const destAmountAfterSlippage = BigInt(
+      // get rid of exponential notation
+
+      +(+deltaPrice.destAmount * (1 - slippagePercent / 100)).toFixed(0)
+      // get rid of decimals
+    ).toString(10);
+
+    const deltaAuction = await simpleSDK.delta.submitDeltaOrder({
+      deltaPrice,
+      owner: account,
+      // beneficiary: anotherAccount, // if need to send destToken to another account
+      // permit: "0x1234...", // if signed a Permit1 or Permit2 TransferFrom for DeltaContract
+      srcToken: DAI_TOKEN,
+      destToken: USDC_TOKEN,
+      srcAmount: amount,
+      destAmount: destAmountAfterSlippage, // minimum acceptable destAmount
+    });
+
+    // poll if necessary
+    const auction = await simpleSDK.delta.getDeltaOrderById(deltaAuction.id);
+    if (auction?.status === 'EXECUTED') {
+      console.log('Auction was executed');
+    }
+  } else {
+    console.log(
+      `Delta Quote failed: ${quote.fallbackReason.errorType} - ${quote.fallbackReason.details}`
+    );
+    const priceRoute = quote.market;
+
+    const TokenTransferProxy = await simpleSDK.swap.getSpender();
+
+    // or sign a Permit1 or Permit2 TransferFrom for TokenTransferProxy
+    const approveTxHash = simpleSDK.swap.approveToken(amount, DAI_TOKEN);
+
+    const txParams = await simpleSDK.swap.buildTx({
+      srcToken: DAI_TOKEN,
+      destToken: USDC_TOKEN,
+      srcAmount: amount,
+      slippage: 250, // 2.5%
+      priceRoute,
+      userAddress: account,
+      // partner: '...' // if available
+    });
+
+    const swapTx = await signer.sendTransaction(txParams);
+  }
+}

package/src/examples/viem.ts

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { createWalletClient, custom } from 'viem';
+import { mainnet } from 'viem/chains';
+
+// declares types for window.ethereum
+import 'viem/window';
+import axios from 'axios';
+import {
+  constructViemContractCaller,
+  constructAxiosFetcher,
+  constructPartialSDK,
+  constructSimpleSDK,
+  constructSubmitLimitOrder,
+  type BuildLimitOrderInput,
+} from '../';
+import { assert } from 'ts-essentials';
+import { txParamsToViemTxParams } from '../helpers/providers/viem';
+
+/**
+ * necessary when using write methods from SDK:
+ * transactions: approve Token, Fill or Cancel Order,
+ * signTypedData: signing Orders.
+ */
+const walletClient = createWalletClient({
+  // either `viemClient` has account assigned to it at creation time,
+  // or the provider `viemClient` was created with must control `account` (viemClient.getAddresses()[0]===account);
+  // otherwise breaks with ` ProviderError: Unknown account 0x...`
+  chain: mainnet,
+  transport: custom(window.ethereum!),
+});
+
+// example of a minimal SDK for submitting Limit Orders only
+async function limitOrderSDKExample() {
+  const [account] = await walletClient.getAddresses();
+  assert(account, 'account is necessary for Order signing');
+
+  const contractCaller = constructViemContractCaller(
+    walletClient,
+    account // pass account to enable write methods (tx signing, signTypedData)
+  );
+  const fetcher = constructAxiosFetcher(axios);
+  // SDK with `submitLimitOrder` and `submitP2POrder` methods only
+  const LOrderSDK = constructPartialSDK(
+    {
+      contractCaller,
+      fetcher,
+      chainId: 1, // same chain as for walletClient
+    },
+    constructSubmitLimitOrder
+  );
+
+  /*
+  // alternatively, SDK with all Order methods: `submitLimitOrder`,  `cancelLimitOrder`, `fillLimitOrder`, `getLimitOrders`, etc. methods
+  const LOrderSDK = constructPartialSDK(
+    {
+      contractCaller,
+      fetcher,
+      chainId: 1, // same chain as for walletClient
+    },
+    constructAllLimitOrdersHandlers
+  ); */
+
+  const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
+  const HEX = '0x2b591e99afe9f32eaa6214f7b7629768c40eeb39';
+
+  const orderInput: BuildLimitOrderInput = {
+    nonce: 1,
+    expiry: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // week from now, in sec
+    makerAsset: DAI,
+    takerAsset: HEX,
+    makerAmount: (1e18).toString(10),
+    takerAmount: (8e18).toString(10),
+    maker: account,
+  };
+
+  // submitted Order if successful
+  const orderFromAPI = LOrderSDK.submitLimitOrder(orderInput);
+}
+
+async function simpleSDKExample() {
+  const [account] = await walletClient.getAddresses();
+  assert(account, 'account is necessary for Order signing');
+
+  const simpleSDK = constructSimpleSDK(
+    {
+      axios,
+      chainId: 1, // same chain as for walletClient
+    },
+    { viemClient: walletClient, account }
+  );
+
+  const ETH = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+  const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
+  const srcAmount = (1 * 1e18).toString();
+
+  const destToken = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
+  const priceRoute = await simpleSDK.swap.getRate({
+    srcToken: ETH,
+    destToken: DAI,
+    amount: srcAmount,
+    userAddress: account,
+    side: 'SELL',
+    srcDecimals: 18,
+    destDecimals: 18,
+  });
+
+  const txParams = await simpleSDK.swap.buildTx({
+    srcToken: ETH,
+    destToken,
+    srcAmount,
+    slippage: 250, // 2.5%
+    priceRoute,
+    userAddress: account,
+  });
+
+  // helper to cast all relevant string values to BigInt
+  const vTxParams = txParamsToViemTxParams(txParams);
+
+  const txHash = await walletClient.sendTransaction({ ...vTxParams, account });
+}

package/src/examples/wagmi.ts

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { mainnet } from '@wagmi/core/chains';
+import {
+  getAccount,
+  getWalletClient,
+  sendTransaction,
+  waitForTransactionReceipt,
+  http,
+  createConfig,
+} from '@wagmi/core';
+import { injected } from '@wagmi/connectors';
+import { constructSimpleSDK, txParamsToViemTxParams } from '../';
+import { assert } from 'ts-essentials';
+
+export const config = createConfig({
+  chains: [mainnet],
+  connectors: [injected()],
+  transports: {
+    [mainnet.id]: http(),
+  },
+});
+
+async function simpleSDKExample() {
+  const walletClient = await getWalletClient(config, { chainId: mainnet.id });
+  const account = getAccount(config).address; // make sure wallet is connected at this point
+  assert(account, 'account is necessary for Order signing');
+
+  const simpleSDK = constructSimpleSDK(
+    {
+      axios,
+      chainId: mainnet.id, // same chain as for walletClient
+    },
+    { viemClient: walletClient, account }
+  );
+
+  const ETH = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+  const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
+  const srcAmount = (1 * 1e18).toString();
+
+  const destToken = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
+  const priceRoute = await simpleSDK.swap.getRate({
+    srcToken: ETH,
+    destToken: DAI,
+    amount: srcAmount,
+    userAddress: account,
+    side: 'SELL',
+    srcDecimals: 18,
+    destDecimals: 18,
+  });
+
+  const txParams = await simpleSDK.swap.buildTx({
+    srcToken: ETH,
+    destToken,
+    srcAmount,
+    slippage: 250, // 2.5%
+    priceRoute,
+    userAddress: account,
+  });
+
+  const vTxParams = txParamsToViemTxParams(txParams);
+
+  const txHash = await sendTransaction(config, vTxParams);
+
+  const txReceipt = waitForTransactionReceipt(config, { hash: txHash });
+}
+
+// Look at examples/viem for more examples

package/src/examples/web3.ts

@@ -0,0 +1,32 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import Web3 from 'web3';
+import {
+  constructFullSDK,
+  constructAxiosFetcher,
+  constructWeb3ContractCaller,
+} from '..';
+
+const fetcher = constructAxiosFetcher(axios);
+const web3 = new Web3(Web3.givenProvider);
+const contractCaller = constructWeb3ContractCaller(web3);
+
+const sdk = constructFullSDK({
+  chainId: 1,
+  fetcher,
+  contractCaller,
+});
+
+async function main() {
+  // type Web3UnpromiEvent
+  const eventfulTxResponse = await sdk.swap.approveToken(
+    '1000000000000000000',
+    '0xcafe001067cDEF266AfB7Eb5A286dCFD277f3dE5'
+  );
+
+  eventfulTxResponse.once('transactionHash', (txHash) =>
+    console.log('watch for tx', txHash)
+  );
+}
+
+main();

package/src/gas.ts

@@ -0,0 +1,7 @@
+export type WithGasPrice = {
+  gasPrice: string;
+};
+export type WithMaxFee = {
+  maxFeePerGas: string;
+  maxPriorityFeePerGas: string;
+};

package/src/helpers/approve.ts

@@ -0,0 +1,60 @@
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../types';
+import type { ExtractAbiMethodNames } from '../helpers/misc';
+import type { Address, PriceString } from './token';
+
+// much smaller than the whole ERC20_ABI
+const MinERC20Abi = [
+  {
+    constant: false,
+    inputs: [
+      { name: '_spender', type: 'address' },
+      { name: '_value', type: 'uint256' },
+    ],
+    name: 'approve',
+    outputs: [{ name: '', type: 'bool' }],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+type ApprovalMethods = ExtractAbiMethodNames<typeof MinERC20Abi>;
+
+type ApproveContractCaller<T> = ConstructProviderFetchInput<
+  T,
+  'transactCall'
+>['contractCaller'];
+
+export type ApproveToken<T> = (
+  amount: PriceString,
+  tokenAddress: Address,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type GetSpenderAsyncOrSync = (
+  requestParams?: RequestParameters
+) => Address | Promise<Address>;
+
+export function approveTokenMethodFactory<T>(
+  contractCaller: ApproveContractCaller<T>,
+  getSpender: GetSpenderAsyncOrSync
+): ApproveToken<T> {
+  return async (amount, tokenAddress, overrides = {}, requestParams) => {
+    const spender = await getSpender(requestParams);
+
+    const res = await contractCaller.transactCall<ApprovalMethods>({
+      address: tokenAddress,
+      abi: MinERC20Abi,
+      contractMethod: 'approve',
+      args: [spender, amount],
+      overrides,
+    });
+
+    return res;
+  };
+}

package/src/helpers/fetchers/axios.ts

@@ -0,0 +1,34 @@
+import type { ExtraFetchParams, FetcherFunction } from '../../types';
+import type { AxiosStatic } from 'axios';
+import { FetcherError } from '../misc';
+
+export type AxiosRequirement = Pick<AxiosStatic, 'request' | 'isAxiosError'>;
+
+export const constructFetcher =
+  (axios: AxiosRequirement, extra?: ExtraFetchParams): FetcherFunction =>
+  async (params) => {
+    try {
+      const { requestParams, ...rest } = params;
+      // adding apiKey to headers if it's provided
+      const headers = extra?.apiKey
+        ? {
+            'X-API-KEY': extra.apiKey,
+            ...rest.headers,
+            ...requestParams?.headers,
+          }
+        : { ...rest.headers, ...requestParams?.headers };
+
+      const allParams = { ...rest, ...requestParams, headers };
+
+      const { data } = await axios.request(allParams);
+
+      return data;
+    } catch (error: any) {
+      if (axios.isAxiosError(error)) {
+        // attach a more meaningful message and other props
+        throw new FetcherError(error);
+      }
+
+      throw error;
+    }
+  };

package/src/helpers/fetchers/fetch.ts

@@ -0,0 +1,67 @@
+import type { ExtraFetchParams, FetcherFunction } from '../../types';
+import { FetcherError } from '../misc';
+
+// @TODO may not work with node-fetch
+type Fetch = typeof fetch;
+
+export const constructFetcher =
+  (fetch: Fetch, extra?: ExtraFetchParams): FetcherFunction =>
+  async (params) => {
+    try {
+      const { url, method, requestParams } = params;
+      const body = method === 'POST' ? JSON.stringify(params.data) : null;
+      // Only JSON response for POST requests
+      const POSTheaders =
+        method === 'POST' && body
+          ? {
+              'Content-Type': 'application/json',
+            }
+          : undefined;
+
+      // adding apiKey to headers if it's provided
+      const apiHeaders = extra?.apiKey
+        ? { 'X-API-KEY': extra.apiKey }
+        : undefined;
+
+      // all headers combined
+      const headers =
+        POSTheaders || apiHeaders || params.headers || requestParams?.headers
+          ? {
+              ...apiHeaders,
+              ...POSTheaders,
+              ...params.headers,
+              ...requestParams?.headers,
+            }
+          : undefined;
+
+      const response = await fetch(url, {
+        method,
+        body,
+        ...requestParams,
+        headers,
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        // @TODO figure out if this works analogous to AxiosError, especially code ==? status
+        throw new FetcherError({
+          code: String(response.status),
+          response: {
+            data,
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+            config: { url, method },
+          },
+          message: response.statusText,
+          isAxiosError: false,
+        });
+      }
+
+      return data;
+    } catch (error: any) {
+      if (error instanceof FetcherError) throw error;
+      throw new FetcherError(error);
+    }
+  };

package/src/helpers/index.ts

@@ -0,0 +1,27 @@
+import { EthersV5ProviderDeps } from './providers/ethers';
+import { EthersV6ProviderDeps } from './providers/ethersV6';
+export { constructFetcher as constructAxiosFetcher } from './fetchers/axios';
+export { constructFetcher as constructFetchFetcher } from './fetchers/fetch';
+export {
+  constructEthersV5ContractCaller as constructEthersContractCaller,
+  constructEthersV5ContractCaller,
+  EthersV5ProviderDeps,
+} from './providers/ethers';
+export {
+  constructContractCaller as constructEthersV6ContractCaller,
+  EthersV6ProviderDeps,
+} from './providers/ethersV6';
+export type EthersProviderDeps = EthersV5ProviderDeps | EthersV6ProviderDeps;
+
+export {
+  constructContractCaller as constructWeb3ContractCaller,
+  Web3UnpromiEvent,
+} from './providers/web3';
+export {
+  constructContractCaller as constructViemContractCaller,
+  MinViemClient,
+  txParamsToViemTxParams,
+} from './providers/viem';
+export { constructToken } from './token';
+export { isFetcherError } from './misc';
+export type { FetcherError, FetcherErrorInterface } from './misc';