@velora-dex/sdk 8.0.0

package/src/methods/delta/getBridgeInfo.ts

@@ -0,0 +1,38 @@
+import { API_URL } from '../../constants';
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+
+// srcChainId -> destChainId -> outputToken[]
+// output Tokens that are supported for a srcChainId -> destChainId pair
+export type BridgeInfo = Record<number, Record<number, Address[]>>;
+type BridgeInfoResponse = { supportedTokens: BridgeInfo };
+
+type GetBridgeInfo = (requestParams?: RequestParameters) => Promise<BridgeInfo>;
+
+export type GetBridgeInfoFunctions = {
+  getBridgeInfo: GetBridgeInfo;
+};
+
+export const constructGetBridgeInfo = ({
+  apiURL = API_URL,
+  fetcher,
+}: ConstructFetchInput): GetBridgeInfoFunctions => {
+  const bridgeInfoUrl = `${apiURL}/delta/prices/bridge-info` as const;
+
+  const getBridgeInfo: GetBridgeInfo = async (requestParams) => {
+    const data = await fetcher<BridgeInfoResponse>({
+      url: bridgeInfoUrl,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.supportedTokens;
+  };
+
+  return {
+    getBridgeInfo,
+  };
+};

package/src/methods/delta/getDeltaContract.ts

@@ -0,0 +1,29 @@
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+import { constructGetSpender } from '../swap/spender';
+
+type GetDeltaContract = (
+  requestParams?: RequestParameters
+) => Promise<Address | null>;
+export type GetDeltaContractFunctions = {
+  /** @description returns ParaswapDelta contract address when Delta is available on current chain */
+  getDeltaContract: GetDeltaContract;
+};
+
+export const constructGetDeltaContract = (
+  options: ConstructFetchInput
+): GetDeltaContractFunctions => {
+  // analogous to getSpender() but for Delta Orders Contract = ParaswapDelta
+
+  const { getContracts } = constructGetSpender(options);
+
+  const getDeltaContract: GetDeltaContract = async (requestParams) => {
+    const { ParaswapDelta } = await getContracts(requestParams);
+    return ParaswapDelta || null;
+  };
+
+  return { getDeltaContract };
+};

package/src/methods/delta/getDeltaOrders.ts

@@ -0,0 +1,102 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+import type { DeltaAuction } from './helpers/types';
+
+type OrderFromAPI = Omit<DeltaAuction, 'signature'>;
+
+type GetDeltaOrderById = (
+  orderId: string,
+  requestParams?: RequestParameters
+) => Promise<OrderFromAPI>;
+
+type GetDeltaOrderByHash = (
+  orderHash: string,
+  requestParams?: RequestParameters
+) => Promise<OrderFromAPI>;
+
+type OrdersFilter = {
+  /** @description Order.owner to fetch Delta Order for */
+  userAddress: Address;
+  /** @description Pagination option, page. Default 1 */
+  page?: number;
+  /** @description Pagination option, limit. Default 100 */
+  limit?: number;
+};
+type OrderFiltersQuery = OrdersFilter;
+
+type GetDeltaOrders = (
+  options: OrdersFilter,
+  requestParams?: RequestParameters
+) => Promise<OrderFromAPI[]>;
+
+export type GetDeltaOrdersFunctions = {
+  getDeltaOrderById: GetDeltaOrderById;
+  getDeltaOrderByHash: GetDeltaOrderByHash;
+  getDeltaOrders: GetDeltaOrders;
+};
+
+export const constructGetDeltaOrders = ({
+  apiURL = API_URL,
+  fetcher,
+}: ConstructFetchInput): GetDeltaOrdersFunctions => {
+  const baseUrl = `${apiURL}/delta/orders` as const;
+
+  const getDeltaOrderById: GetDeltaOrderById = async (
+    orderId,
+    requestParams
+  ) => {
+    const fetchURL = `${baseUrl}/${orderId}` as const;
+
+    const order = await fetcher<OrderFromAPI>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return order;
+  };
+
+  const getDeltaOrderByHash: GetDeltaOrderByHash = async (
+    orderHash,
+    requestParams
+  ) => {
+    const fetchURL = `${baseUrl}/hash/${orderHash}` as const;
+
+    const order = await fetcher<OrderFromAPI>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return order;
+  };
+
+  const getDeltaOrders: GetDeltaOrders = async (options, requestParams) => {
+    const search = constructSearchString<OrderFiltersQuery>({
+      userAddress: options.userAddress,
+      page: options.page,
+      limit: options.limit,
+    });
+
+    const fetchURL = `${baseUrl}${search}` as const;
+
+    const orders = await fetcher<OrderFromAPI[]>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return orders;
+  };
+
+  return {
+    getDeltaOrderById,
+    getDeltaOrderByHash,
+    getDeltaOrders,
+  };
+};

package/src/methods/delta/getDeltaPrice.ts

@@ -0,0 +1,122 @@
+import { API_URL, SwapSide } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+
+export type DeltaPriceParams = {
+  /** @description Source Token Address. Not Native Token */
+  srcToken: string;
+  /** @description Destination Token Address */
+  destToken: string;
+  /** @description srcToken amount in wei */
+  amount: string;
+  /** @description Source Token Decimals */
+  srcDecimals: number;
+  /** @description Destination Token Decimals */
+  destDecimals: number;
+  // side?: SwapSide; // no BUY side for now
+  /** @description User's Wallet Address */
+  userAddress?: string;
+  /** @description Partner string. */
+  partner?: string;
+  /** @description Destination Chain ID for Crosschain Orders */
+  destChainId?: number;
+};
+
+type DeltaPriceQueryOptions = DeltaPriceParams & {
+  chainId: number; // will return error from API on unsupported chains
+  side: SwapSide.SELL;
+};
+
+export type DeltaPrice = {
+  srcToken: string;
+  destToken: string;
+  srcAmount: string;
+  destAmount: string;
+  destAmountBeforeFee: string;
+  gasCost: string;
+  gasCostBeforeFee: string;
+  gasCostUSD: string;
+  gasCostUSDBeforeFee: string;
+  srcUSD: string;
+  destUSD: string;
+  destUSDBeforeFee: string;
+  partner: string;
+  partnerFee: number; // in %
+  hmac: string;
+};
+
+export type BridgePrice = DeltaPrice & {
+  destAmountAfterBridge: string;
+  destUSDAfterBridge: string;
+  bridgeFee: string;
+  bridgeFeeUSD: string;
+  poolAddress: string;
+};
+
+type DeltaPriceResponse = {
+  price: DeltaPrice | BridgePrice;
+  deltaAddress: string;
+};
+
+interface GetDeltaPrice {
+  (
+    options: DeltaPriceParams & { destChainId: number },
+    requestParams?: RequestParameters
+  ): Promise<BridgePrice>;
+  (
+    options: DeltaPriceParams & { destChainId?: undefined },
+    requestParams?: RequestParameters
+  ): Promise<DeltaPrice>;
+  (options: DeltaPriceParams, requestParams?: RequestParameters): Promise<
+    DeltaPrice | BridgePrice
+  >;
+}
+
+export type GetDeltaPriceFunctions = {
+  getDeltaPrice: GetDeltaPrice;
+};
+
+export const constructGetDeltaPrice = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): GetDeltaPriceFunctions => {
+  const pricesUrl = `${apiURL}/delta/prices` as const;
+
+  async function getDeltaPrice(
+    options: DeltaPriceParams & { destChainId: number },
+    requestParams?: RequestParameters
+  ): Promise<BridgePrice>;
+  async function getDeltaPrice(
+    options: DeltaPriceParams & { destChainId?: undefined },
+    requestParams?: RequestParameters
+  ): Promise<DeltaPrice>;
+  async function getDeltaPrice(
+    options: DeltaPriceParams,
+    requestParams?: RequestParameters
+  ): Promise<DeltaPrice | BridgePrice>;
+  async function getDeltaPrice(
+    options: DeltaPriceParams,
+    requestParams?: RequestParameters
+  ): Promise<DeltaPrice | BridgePrice> {
+    const search = constructSearchString<DeltaPriceQueryOptions>({
+      ...options,
+      chainId,
+      side: SwapSide.SELL, // so far SELL side only
+    });
+
+    const fetchURL = `${pricesUrl}/${search}` as const;
+
+    const data = await fetcher<DeltaPriceResponse>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.price;
+  }
+
+  return {
+    getDeltaPrice,
+  };
+};

package/src/methods/delta/getMulticallHandlers.ts

@@ -0,0 +1,44 @@
+import { API_URL } from '../../constants';
+import { runOnceAndCache } from '../../helpers/misc';
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+
+// chainId -> multicallHandler
+export type MulticallHandlersResponse = Record<number, Address>;
+
+type GetMulticallHandlers = (
+  requestParams?: RequestParameters
+) => Promise<MulticallHandlersResponse>;
+
+export type GetMulticallHandlersFunctions = {
+  getMulticallHandlers: GetMulticallHandlers;
+};
+
+export const constructGetMulticallHandlers = ({
+  apiURL = API_URL,
+  fetcher,
+}: ConstructFetchInput): GetMulticallHandlersFunctions => {
+  const multicallHandlersUrl =
+    `${apiURL}/delta/prices/multicall-handlers` as const;
+
+  const _getMulticallHandlers: GetMulticallHandlers = async (requestParams) => {
+    const data = await fetcher<MulticallHandlersResponse>({
+      url: multicallHandlersUrl,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data;
+  };
+
+  // cached for the same instance of `{getMulticallHandlers} = constructGetMulticallHandlers()`
+  // so should persist across same apiUrl & network (and response is even network agnostic)
+  const getMulticallHandlers = runOnceAndCache(_getMulticallHandlers);
+
+  return {
+    getMulticallHandlers,
+  };
+};

package/src/methods/delta/getPartnerFee.ts

@@ -0,0 +1,58 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+
+export type PartnerFeeResponse = {
+  partnerFee: number; // in %, e.g. 0.12
+  partnerAddress: string;
+  takeSurplus: boolean;
+};
+
+type PartnerFeeQueryParams = {
+  partner: string;
+};
+
+type GetPartnerFee = (
+  options: PartnerFeeQueryParams,
+  requestParams?: RequestParameters
+) => Promise<PartnerFeeResponse>;
+
+export type GetPartnerFeeFunctions = {
+  getPartnerFee: GetPartnerFee;
+};
+
+export const constructGetPartnerFee = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): GetPartnerFeeFunctions => {
+  const partnerFeeUrl = `${apiURL}/prices/partnerfee/${chainId}` as const;
+
+  // going on the assumption that one `partner` will correspond to one `partnerFee` during the lifetime of SDK instance,
+  // to avoid unnecessary network requests
+  const cachedPartnerFee = new Map<string, PartnerFeeResponse>();
+
+  const getPartnerFee: GetPartnerFee = async (options, requestParams) => {
+    if (cachedPartnerFee.has(options.partner)) {
+      return cachedPartnerFee.get(options.partner)!;
+    }
+
+    const search = constructSearchString<PartnerFeeQueryParams>(options);
+
+    const fetchURL = `${partnerFeeUrl}/${search}` as const;
+
+    const data = await fetcher<PartnerFeeResponse>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    cachedPartnerFee.set(options.partner, data);
+
+    return data;
+  };
+
+  return {
+    getPartnerFee,
+  };
+};

package/src/methods/delta/helpers/across.ts

@@ -0,0 +1,255 @@
+import { assert } from 'ts-essentials';
+import { ZERO_ADDRESS } from '../../common/orders/buildOrderData';
+import { BeneficiaryType } from '../../common/orders/types';
+import { Bridge, DeltaAuctionOrder } from './types';
+
+export const ACROSS_WETH_ADDRESSES_MAP: Record<number, string> = {
+  // Mainnet
+  1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+  // Sepolia
+  11155111: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14',
+  // Base
+  8453: '0x4200000000000000000000000000000000000006',
+  // Base Sepolia
+  84532: '0x4200000000000000000000000000000000000006',
+  // Optimism
+  10: '0x4200000000000000000000000000000000000006',
+  // Optimism Sepolia
+  11155420: '0x4200000000000000000000000000000000000006',
+  // Polygon
+  137: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619',
+  // Polygon Amoy
+  80002: '0x52eF3d68BaB452a294342DC3e5f464d7f610f72E',
+  // Aleph Zero
+  41455: '0xB3f0eE446723f4258862D949B4c9688e7e7d35d3',
+  // Arbitrum
+  42161: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+  // Arbitrum Sepolia
+  421614: '0x980B62Da83eFf3D4576C647993b0c1D7faf17c73',
+  // Boba
+  288: '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000',
+  // Blast
+  81457: '0x4300000000000000000000000000000000000004',
+  // Blast Sepolia
+  168587773: '0x4200000000000000000000000000000000000023',
+  // Ink
+  57073: '0x4200000000000000000000000000000000000006',
+  // Ink Sepolia
+  763373: '0x4200000000000000000000000000000000000006',
+  // Lens
+  232: '0xE5ecd226b3032910CEaa43ba92EE8232f8237553',
+  // Lens Sepolia
+  37111: '0xaA91D645D7a6C1aeaa5988e0547267B77d33fe16',
+  // Linea
+  59144: '0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f',
+  // Lisk
+  1135: '0x4200000000000000000000000000000000000006',
+  // Lisk Sepolia
+  4202: '0x4200000000000000000000000000000000000006',
+  // Mode
+  34443: '0x4200000000000000000000000000000000000006',
+  // Mode Sepolia
+  919: '0x4200000000000000000000000000000000000006',
+  // Redstone
+  690: '0x4200000000000000000000000000000000000006',
+  // Scroll
+  534352: '0x5300000000000000000000000000000000000004',
+  // Scroll Sepolia
+  534351: '0x5300000000000000000000000000000000000004',
+  // Soneium
+  1868: '0x4200000000000000000000000000000000000006',
+  // Tatara
+  129399: '0x17B8Ee96E3bcB3b04b3e8334de4524520C51caB4',
+  // Unichain
+  130: '0x4200000000000000000000000000000000000006',
+  // Unichain Sepolia
+  1301: '0x4200000000000000000000000000000000000006',
+  // World Chain
+  480: '0x4200000000000000000000000000000000000006',
+  // ZK Sync
+  324: '0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91',
+  // ZK Sync Sepolia
+  300: '0x2D6Db36B3117802E996f13073A08A685D3FeF7eD',
+  // Zora
+  7777777: '0x4200000000000000000000000000000000000006',
+};
+
+export function isAcrossWETH(tokenAddress: string, chainId: number) {
+  return (
+    ACROSS_WETH_ADDRESSES_MAP[chainId]?.toLowerCase() ===
+    tokenAddress.toLowerCase()
+  );
+}
+
+const ETH_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+
+const ETH_ADDRESS_LOWERCASE = ETH_ADDRESS.toLowerCase() as Lowercase<
+  typeof ETH_ADDRESS
+>;
+
+export function isETHaddress(tokenAddress: string): boolean {
+  return tokenAddress.toLowerCase() === ETH_ADDRESS_LOWERCASE;
+}
+
+// WETH > ETH Across logic
+// https://docs.across.to/introduction/technical-faq#what-is-the-behavior-of-eth-weth-in-transfers
+
+// Velora API ref
+// https://developers.velora.xyz/api/velora-api/velora-delta-api/build-a-delta-order-to-sign
+
+export type GetDeltaBridgeAndDestTokenInput = {
+  destTokenDestChain: string;
+  destChainId: number;
+  destTokenSrcChain: string;
+  srcChainId: number;
+  bridgeFee: string;
+  beneficiaryType: BeneficiaryType;
+  getMulticallHandler: (chainId: number) => Promise<string>;
+};
+
+export type GetDeltaBridgeAndDestTokenOutput = {
+  /** @description The bridge object to be used for Order.bridge */
+  bridge: Bridge;
+  /** @description The changes to be made to the Order */
+  orderChanges: Pick<DeltaAuctionOrder, 'destToken'>;
+};
+
+export async function getDeltaBridgeAndDestToken({
+  destTokenDestChain,
+  destChainId,
+  destTokenSrcChain,
+  srcChainId,
+  bridgeFee,
+  beneficiaryType,
+  getMulticallHandler,
+}: GetDeltaBridgeAndDestTokenInput): Promise<GetDeltaBridgeAndDestTokenOutput> {
+  assert(
+    beneficiaryType === 'EOA' || beneficiaryType === 'SmartContract',
+    'beneficiaryType must be EOA or SmartContract'
+  );
+  const WETH_SRC_CHAIN = ACROSS_WETH_ADDRESSES_MAP[srcChainId];
+
+  const WETH_DEST_CHAIN = ACROSS_WETH_ADDRESSES_MAP[destChainId];
+
+  if (!WETH_SRC_CHAIN || !WETH_DEST_CHAIN) {
+    // this should never happen as we only expect crosschain Delta Orders for supported chains
+    const bridge: Bridge = {
+      maxRelayerFee: bridgeFee,
+      destinationChainId: destChainId,
+      outputToken: destTokenDestChain,
+      multiCallHandler: ZERO_ADDRESS,
+    };
+
+    return {
+      bridge,
+      orderChanges: {
+        destToken: destTokenSrcChain,
+      },
+    };
+  }
+
+  if (beneficiaryType === 'EOA' && isETHaddress(destTokenDestChain)) {
+    /*
+    if beneficiary is an EOA and destToken on destChain = ETH
+    order.destToken=ETH
+    order.bridge.outputToken=WETH_DEST_CHAIN
+    order.bridge.multiCallHandler=NULL_ADDRESS
+    */
+
+    const bridge: Bridge = {
+      maxRelayerFee: bridgeFee,
+      destinationChainId: destChainId,
+      outputToken: WETH_DEST_CHAIN,
+      multiCallHandler: ZERO_ADDRESS,
+    };
+
+    return {
+      bridge,
+      orderChanges: {
+        destToken: ETH_ADDRESS,
+      },
+    };
+  }
+  if (
+    beneficiaryType === 'EOA' &&
+    isAcrossWETH(destTokenDestChain, destChainId)
+  ) {
+    /*
+    if beneficiary is an EOA and destToken on destChain = WETH
+    order.destToken=WETH
+    order.bridge.outputToken=WETH_DEST_CHAIN
+    order.bridge.multiCallHandler=MULTI_CALL_HANDLER
+    */
+    const bridge: Bridge = {
+      maxRelayerFee: bridgeFee,
+      destinationChainId: destChainId,
+      outputToken: WETH_DEST_CHAIN,
+      multiCallHandler: await getMulticallHandler(destChainId),
+    };
+    return {
+      bridge,
+      orderChanges: {
+        destToken: WETH_SRC_CHAIN,
+      },
+    };
+  }
+
+  if (beneficiaryType === 'SmartContract' && isETHaddress(destTokenDestChain)) {
+    /* 
+      if beneficiary is a contract and destToken on destChain = ETH
+      order.destToken=ETH
+      order.bridge.outputToken=WETH_DEST_CHAIN
+      order.bridge.multiCallHandler=MULTI_CALL_HANDLER
+      */
+    const bridge: Bridge = {
+      maxRelayerFee: bridgeFee,
+      destinationChainId: destChainId,
+      outputToken: WETH_DEST_CHAIN,
+      multiCallHandler: await getMulticallHandler(destChainId),
+    };
+    return {
+      bridge,
+      orderChanges: {
+        destToken: ETH_ADDRESS,
+      },
+    };
+  }
+
+  if (
+    beneficiaryType === 'SmartContract' &&
+    isAcrossWETH(destTokenDestChain, destChainId)
+  ) {
+    /*
+      if beneficiary is a contract and destToken on destChain = WETH
+      order.destToken=WETH
+      order.bridge.outputToken=WETH_DEST_CHAIN
+      order.bridge.multiCallHandler=NULL_ADDRESS
+    */
+    const bridge: Bridge = {
+      maxRelayerFee: bridgeFee,
+      destinationChainId: destChainId,
+      outputToken: WETH_DEST_CHAIN,
+      multiCallHandler: ZERO_ADDRESS,
+    };
+    return {
+      bridge,
+      orderChanges: {
+        destToken: WETH_SRC_CHAIN,
+      },
+    };
+  }
+
+  const bridge: Bridge = {
+    maxRelayerFee: bridgeFee,
+    destinationChainId: destChainId,
+    outputToken: destTokenDestChain,
+    multiCallHandler: ZERO_ADDRESS,
+  };
+
+  return {
+    bridge,
+    orderChanges: {
+      destToken: destTokenSrcChain,
+    },
+  };
+}