@velora-dex/sdk 8.0.0

package/src/helpers/providers/web3.ts

@@ -0,0 +1,154 @@
+import type {
+  Address,
+  ContractCallerFunctions,
+  SignTypedDataContractCallerFn,
+  StaticContractCallerFn,
+  TransactionContractCallerFn,
+} from '../../types';
+import type { PayableCallOptions, AbiItem } from 'web3';
+import type Web3 from 'web3';
+import type { ContractAbi, Contract as Web3Contract } from 'web3';
+import type { PayableTxOptions } from 'web3-eth-contract';
+import { assert } from 'ts-essentials';
+import { findPrimaryType } from './helpers';
+
+type ContractMethodRes = ReturnType<Web3ContractSendMethod>;
+export type Web3UnpromiEvent = Pick<
+  ReturnType<ContractMethodRes['send']>,
+  'on' | 'once'
+>;
+
+type SendOptions = PayableTxOptions;
+type CallOptions = PayableCallOptions;
+
+export const constructContractCaller = (
+  web3: Web3,
+  account?: Address
+): ContractCallerFunctions<Web3UnpromiEvent> => {
+  const staticCall: StaticContractCallerFn = async (params) => {
+    assert(web3.currentProvider, 'web3.currentProvider is not set');
+
+    const { address, abi, contractMethod, args, overrides } = params;
+
+    const contract = new web3.eth.Contract(
+      abi as AbiItem[], // FIXME abi types ethers dependant
+      address
+    );
+
+    assertWeb3ContractHasMethods(contract, contractMethod);
+
+    const { block, gas, value, ...restOverrides } = overrides;
+
+    const normalizedOverrides: CallOptions = {
+      ...restOverrides,
+      gas: gas?.toString(10),
+      value: value?.toString(10),
+    };
+
+    return contract.methods[contractMethod](...args).call(normalizedOverrides);
+  };
+
+  const transactCall: TransactionContractCallerFn<Web3UnpromiEvent> = async (
+    params
+  ) => {
+    assert(web3.currentProvider, 'web3.currentProvider is not set');
+
+    assert(account, 'account must be specified to send transactions');
+
+    const { address, abi, contractMethod, args, overrides } = params;
+
+    const contract = new web3.eth.Contract(
+      abi as unknown as AbiItem[], // FIXME
+      address
+    );
+
+    assertWeb3ContractHasMethods(contract, contractMethod);
+
+    const { gas, from, value, nonce, ...restOverrides } = overrides;
+
+    const _from = from || account;
+
+    assert(_from, 'from is required');
+
+    const normalizedOverrides: SendOptions = {
+      ...restOverrides,
+      from: _from,
+      gas: gas?.toString(10),
+      value: value?.toString(10),
+      nonce: nonce?.toString(10),
+    };
+
+    const preparedCall = contract.methods[contractMethod](...args);
+
+    const promiEvent = preparedCall.send(normalizedOverrides);
+
+    // can't just return promiEvent, because async function returns a Promise<PromiEvent>
+    // and await Promise<PromiEvent> automatically awaits the value of PromiEvent,
+    // that is await Promise<PromiEvent> = Awaited<PromiEvent> that doesn't have .on|once
+    // so that functionality becomes lost
+    // transactCall can be made sync, but approve has to be async to await getSpender()
+    const unpromiEvent: Web3UnpromiEvent = {
+      on: promiEvent.on.bind(promiEvent),
+      once: promiEvent.once.bind(promiEvent),
+    };
+
+    return unpromiEvent;
+  };
+
+  const signTypedDataCall: SignTypedDataContractCallerFn = async (
+    typedData
+  ) => {
+    assert(web3.currentProvider, 'web3.currentProvider is not set');
+
+    assert(account, 'account must be specified to sign data');
+
+    const { data, domain, types } = typedData;
+
+    const _typedData = {
+      types: {
+        EIP712Domain: [
+          { name: 'name', type: 'string' },
+          { name: 'version', type: 'string' },
+          { name: 'chainId', type: 'uint256' },
+          { name: 'verifyingContract', type: 'address' },
+        ],
+        ...types,
+      },
+      primaryType: findPrimaryType(types),
+      domain,
+      message: data,
+    };
+
+    // account must be among unlocked accounts
+    const signature = await web3.eth.signTypedData(account, _typedData as any);
+    return signature;
+  };
+
+  return { staticCall, transactCall, signTypedDataCall };
+};
+
+/// web3@4
+type Web3ContractSendMethod = Web3Contract<ContractAbi>['methods'][string];
+
+type Web3ContractWithMethod<T extends string> = Web3Contract<ContractAbi> & {
+  methods: { [method in T]: Web3ContractSendMethod };
+};
+
+function web3ContractHasMethods<T extends string>(
+  contract: Web3Contract<ContractAbi>,
+  ...methods: T[]
+): contract is Web3ContractWithMethod<T> {
+  return methods.every(
+    (method) => typeof contract.methods[method] === 'function'
+  );
+}
+
+function assertWeb3ContractHasMethods<T extends string>(
+  contract: Web3Contract<ContractAbi>,
+  ...methods: T[]
+): asserts contract is Web3ContractWithMethod<T> {
+  assert(
+    web3ContractHasMethods(contract, ...methods),
+    `Contract must have methods: ${methods.join(', ')}`
+  );
+}

package/src/helpers/token.ts

@@ -0,0 +1,75 @@
+import type { MarkOptional } from 'ts-essentials';
+
+/**
+ * @type hex token or account address
+ */
+export type Address = string;
+/**
+ * @type hex token address or token symbol
+ */
+export type AddressOrSymbol = string;
+/**
+ * @type number in string form
+ */
+export type PriceString = string;
+/**
+ * @type transaction hash
+ */
+export type TxHash = `0x${string}`;
+
+// @TODO sync with what it actually is
+export type LendingToken =
+  | 'cToken'
+  | 'iToken'
+  | 'aToken'
+  | 'aToken2'
+  | 'idleToken'
+  | 'Chai'
+  | 'bDAI';
+
+export type TokenType = 'ETH' | 'ERC20' | 'SYNTH';
+
+/**
+ * @type Token object returned from API used internally in API
+ */
+// consider if need the old class Token for backwards compatipility
+// otherwise no real need
+export type Token = {
+  address: string;
+  decimals: number;
+  symbol?: string | undefined;
+  tokenType: LendingToken | TokenType;
+  mainConnector: string;
+  connectors: string[];
+  network: number;
+  img?: string | undefined;
+  allowance?: string | undefined;
+  balance?: string | undefined;
+};
+
+type ConstructTokenInput = MarkOptional<
+  Token,
+  // these props are constructed from other, required props
+  'tokenType' | 'mainConnector' | 'connectors' | 'network'
+>;
+
+export const constructToken = (tokenProps: ConstructTokenInput): Token => {
+  const {
+    tokenType = 'ERC20',
+    mainConnector = 'ETH',
+    connectors: connectorsInput = [],
+    network = 1,
+    ...rest
+  } = tokenProps;
+
+  const connectors: Token['connectors'] =
+    connectorsInput.length > 0 ? connectorsInput : [mainConnector];
+
+  return {
+    tokenType,
+    connectors,
+    mainConnector,
+    network,
+    ...rest,
+  };
+};

package/src/index.ts

@@ -0,0 +1,425 @@
+import {
+  constructApproveToken,
+  ApproveTokenFunctions,
+} from './methods/swap/approve';
+import {
+  constructGetBalances,
+  GetBalancesFunctions,
+  isAllowance,
+  Allowance,
+} from './methods/swap/balance';
+import {
+  constructGetSpender,
+  GetSpenderFunctions,
+} from './methods/swap/spender';
+import {
+  constructGetAdapters,
+  GetAdaptersFunctions,
+} from './methods/swap/adapters';
+import { constructGetRate, GetRateFunctions } from './methods/swap/rates';
+import { constructSwapTx, GetSwapTxFunctions } from './methods/swap/swapTx';
+import { constructGetTokens, GetTokensFunctions } from './methods/swap/token';
+import { BuildTxFunctions, constructBuildTx } from './methods/swap/transaction';
+
+import {
+  BuildLimitOrderFunctions,
+  BuildLimitOrderInput,
+  BuildOrderDataInput,
+  constructBuildLimitOrder,
+} from './methods/limitOrders/buildOrder';
+import {
+  SignLimitOrderFunctions,
+  constructSignLimitOrder,
+} from './methods/limitOrders/signOrder';
+import {
+  CancelLimitOrderFunctions,
+  constructCancelLimitOrder,
+} from './methods/limitOrders/cancelOrder';
+import {
+  FillOrderDirectlyFunctions,
+  constructFillOrderDirectly,
+} from './methods/limitOrders/fillOrderDirectly';
+import {
+  GetLimitOrdersFunctions,
+  constructGetLimitOrders,
+  LimitOrdersUserParams,
+} from './methods/limitOrders/getOrders';
+import {
+  PostLimitOrderFunctions,
+  constructPostLimitOrder,
+} from './methods/limitOrders/postOrder';
+import {
+  ApproveTokenForLimitOrderFunctions,
+  constructApproveTokenForLimitOrder,
+} from './methods/limitOrders/approveForOrder';
+import {
+  GetLimitOrdersContractFunctions,
+  constructGetLimitOrdersContract,
+} from './methods/limitOrders/getOrdersContract';
+import {
+  BuildLimitOrdersTxFunctions,
+  constructBuildLimitOrderTx,
+} from './methods/limitOrders/transaction';
+
+import {
+  BuildNFTOrderFunctions,
+  BuildNFTOrderInput,
+  BuildNFTOrderDataInput,
+  constructBuildNFTOrder,
+} from './methods/nftOrders/buildOrder';
+import {
+  SignNFTOrderFunctions,
+  constructSignNFTOrder,
+} from './methods/nftOrders/signOrder';
+import {
+  CancelNFTOrderFunctions,
+  constructCancelNFTOrder,
+} from './methods/nftOrders/cancelOrder';
+import {
+  GetNFTOrdersFunctions,
+  constructGetNFTOrders,
+  NFTOrdersUserParams,
+} from './methods/nftOrders/getOrders';
+import {
+  PostNFTOrderFunctions,
+  constructPostNFTOrder,
+} from './methods/nftOrders/postOrder';
+import {
+  ApproveTokenForNFTOrderFunctions,
+  constructApproveTokenForNFTOrder,
+} from './methods/nftOrders/approveForOrder';
+import {
+  GetNFTOrdersContractFunctions,
+  constructGetNFTOrdersContract,
+} from './methods/nftOrders/getOrdersContract';
+import {
+  BuildNFTOrdersTxFunctions,
+  constructBuildNFTOrderTx,
+} from './methods/nftOrders/transaction';
+
+import {
+  constructEthersContractCaller,
+  constructEthersV5ContractCaller,
+  constructEthersV6ContractCaller,
+  constructWeb3ContractCaller,
+  constructViemContractCaller,
+  txParamsToViemTxParams,
+  constructAxiosFetcher,
+  constructFetchFetcher,
+  isFetcherError,
+  FetcherErrorInterface,
+  EthersProviderDeps,
+  EthersV5ProviderDeps,
+  EthersV6ProviderDeps,
+  MinViemClient,
+  constructToken,
+  FetcherError,
+} from './helpers';
+import type {
+  ConstructFetchInput,
+  ContractCallerFunctions,
+  ConstructProviderFetchInput,
+  Address,
+  AddressOrSymbol,
+  FetcherFunction,
+  Token,
+  PriceString,
+  TxHash,
+  TxSendOverrides,
+  OptimalRate,
+  OptionalRate,
+  APIVersion,
+} from './types';
+
+import type {
+  DeltaAuctionOrder,
+  DeltaAuction,
+  BridgeMetadata,
+  BridgeStatus,
+  Bridge,
+} from './methods/delta/helpers/types';
+import {
+  BuildDeltaOrderDataParams,
+  BuildDeltaOrderFunctions,
+  constructBuildDeltaOrder,
+  SignableDeltaOrderData,
+} from './methods/delta/buildDeltaOrder';
+import {
+  constructBuildCrosschainOrderBridge,
+  BuildCrosschainOrderBridgeFunctions,
+  BuildCrosschainOrderBridgeParams,
+  CrosschainOrderBridgeAndChanges,
+} from './methods/delta/buildCrosschainOrderBridge';
+import {
+  constructPostDeltaOrder,
+  PostDeltaOrderFunctions,
+  PostDeltaOrderParams,
+} from './methods/delta/postDeltaOrder';
+import {
+  constructSignDeltaOrder,
+  SignDeltaOrderFunctions,
+} from './methods/delta/signDeltaOrder';
+import {
+  GetDeltaContractFunctions,
+  constructGetDeltaContract,
+} from './methods/delta/getDeltaContract';
+import {
+  constructGetDeltaPrice,
+  GetDeltaPriceFunctions,
+  DeltaPrice,
+  BridgePrice,
+  DeltaPriceParams,
+} from './methods/delta/getDeltaPrice';
+import {
+  constructGetDeltaOrders,
+  GetDeltaOrdersFunctions,
+} from './methods/delta/getDeltaOrders';
+import {
+  ApproveTokenForDeltaFunctions,
+  constructApproveTokenForDelta,
+} from './methods/delta/approveForDelta';
+import {
+  constructGetPartnerFee,
+  GetPartnerFeeFunctions,
+} from './methods/delta/getPartnerFee';
+import {
+  constructGetBridgeInfo,
+  GetBridgeInfoFunctions,
+  BridgeInfo,
+} from './methods/delta/getBridgeInfo';
+import {
+  constructGetMulticallHandlers,
+  GetMulticallHandlersFunctions,
+  MulticallHandlersResponse,
+} from './methods/delta/getMulticallHandlers';
+import {
+  constructIsTokenSupportedInDelta,
+  IsTokenSupportedInDeltaFunctions,
+} from './methods/delta/isTokenSupportedInDelta';
+
+import {
+  constructGetQuote,
+  GetQuoteFunctions,
+  QuoteParams,
+  QuoteResponse,
+  QuoteWithDeltaPrice,
+  QuoteWithMarketPrice,
+  QuoteWithMarketPriceAsFallback,
+} from './methods/quote/getQuote';
+
+export { constructSwapSDK, SwapSDKMethods } from './methods/swap';
+
+export {
+  constructAllLimitOrdersHandlers,
+  constructSubmitLimitOrder,
+  LimitOrderHandlers,
+} from './methods/limitOrders';
+
+export {
+  constructAllDeltaOrdersHandlers,
+  constructSubmitDeltaOrder,
+  DeltaOrderHandlers,
+  SubmitDeltaOrderParams,
+} from './methods/delta';
+
+export type {
+  TransactionParams,
+  BuildOptions,
+  BuildOptionsBase,
+  BuildOptionsWitWithMaxFee,
+  BuildOptionsWithGasPrice,
+  BuildTxInput,
+  BuildSwapTxInput,
+  BuildLimitOrderTxInput,
+  BuildNFTOrderTxInput,
+  BuildSwapAndLimitOrderTxInput,
+  BuildSwapAndNFTOrderTxInput,
+  SwappableOrder,
+  SwappableNFTOrder,
+} from './methods/swap/transaction';
+export type { Web3UnpromiEvent } from './helpers';
+export * from './constants';
+export type {
+  SignableOrderData,
+  OrderData,
+} from './methods/limitOrders/helpers/buildOrderData';
+export type {
+  SignableNFTOrderData,
+  NFTOrderData,
+} from './methods/nftOrders/helpers/buildOrderData';
+export type { SignableTypedData } from './methods/common/orders/buildOrderData';
+
+// can import these individually
+// and use in constructPartialSDK only what you need
+// unused should tree-shake
+export {
+  // swap methods:
+  constructApproveToken,
+  constructGetBalances, // getAllowances is inside
+  constructGetSpender, // this was getTokenTransferProxy
+  constructGetTokens,
+  constructBuildTx,
+  constructGetAdapters,
+  constructGetRate,
+  constructSwapTx,
+  // limitOrders methods:
+  constructBuildLimitOrder,
+  constructSignLimitOrder,
+  constructCancelLimitOrder,
+  constructFillOrderDirectly,
+  constructGetLimitOrders,
+  constructPostLimitOrder,
+  constructApproveTokenForLimitOrder,
+  constructGetLimitOrdersContract,
+  constructBuildLimitOrderTx,
+  // nftOrders methods
+  constructBuildNFTOrder,
+  constructSignNFTOrder,
+  constructCancelNFTOrder,
+  constructGetNFTOrders,
+  constructPostNFTOrder,
+  constructApproveTokenForNFTOrder,
+  constructGetNFTOrdersContract,
+  constructBuildNFTOrderTx,
+  // Delta methods
+  constructBuildDeltaOrder,
+  constructBuildCrosschainOrderBridge,
+  constructPostDeltaOrder,
+  constructSignDeltaOrder,
+  constructGetDeltaContract,
+  constructGetDeltaPrice,
+  constructGetDeltaOrders,
+  constructApproveTokenForDelta,
+  // Quote methods
+  constructGetQuote,
+  // different helpers
+  constructGetPartnerFee,
+  constructGetBridgeInfo,
+  constructIsTokenSupportedInDelta,
+  constructGetMulticallHandlers,
+  constructEthersContractCaller, // same as constructEthersV5ContractCaller for backwards compatibility
+  constructEthersV5ContractCaller,
+  constructEthersV6ContractCaller,
+  constructWeb3ContractCaller,
+  constructViemContractCaller,
+  txParamsToViemTxParams,
+  constructAxiosFetcher,
+  constructFetchFetcher,
+  isFetcherError,
+  isAllowance,
+  constructToken,
+  // custom fetcher
+  FetcherError,
+  FetcherFunction,
+};
+
+export type {
+  Allowance,
+  // contractCaller requirements
+  EthersProviderDeps,
+  EthersV5ProviderDeps,
+  EthersV6ProviderDeps,
+  MinViemClient,
+  // types for swap methods:
+  ApproveTokenFunctions,
+  GetBalancesFunctions,
+  GetSpenderFunctions,
+  GetTokensFunctions,
+  GetAdaptersFunctions,
+  GetRateFunctions,
+  BuildTxFunctions,
+  GetSwapTxFunctions,
+  // types for limitOrders methods:
+  BuildLimitOrderFunctions,
+  SignLimitOrderFunctions,
+  CancelLimitOrderFunctions,
+  FillOrderDirectlyFunctions,
+  GetLimitOrdersContractFunctions,
+  BuildLimitOrdersTxFunctions,
+  BuildLimitOrderInput,
+  BuildOrderDataInput,
+  PostLimitOrderFunctions,
+  ApproveTokenForLimitOrderFunctions,
+  GetLimitOrdersFunctions,
+  LimitOrdersUserParams,
+  // types for nftOrders methods:
+  SignNFTOrderFunctions,
+  CancelNFTOrderFunctions,
+  GetNFTOrdersFunctions,
+  PostNFTOrderFunctions,
+  ApproveTokenForNFTOrderFunctions,
+  GetNFTOrdersContractFunctions,
+  BuildNFTOrdersTxFunctions,
+  BuildNFTOrderFunctions,
+  BuildNFTOrderInput,
+  BuildNFTOrderDataInput,
+  NFTOrdersUserParams,
+  //types for Delta methods
+  DeltaPrice,
+  BridgePrice,
+  DeltaPriceParams,
+  DeltaAuctionOrder,
+  DeltaAuction,
+  // bridge part of DeltaOrder
+  BridgeMetadata,
+  BridgeStatus,
+  Bridge,
+  BridgeInfo,
+  BuildDeltaOrderDataParams,
+  BuildDeltaOrderFunctions,
+  SignableDeltaOrderData,
+  BuildCrosschainOrderBridgeFunctions,
+  BuildCrosschainOrderBridgeParams,
+  CrosschainOrderBridgeAndChanges,
+  PostDeltaOrderFunctions,
+  PostDeltaOrderParams,
+  SignDeltaOrderFunctions,
+  GetDeltaContractFunctions,
+  GetDeltaPriceFunctions,
+  GetDeltaOrdersFunctions,
+  ApproveTokenForDeltaFunctions,
+  // types for Quote methods
+  GetQuoteFunctions,
+  QuoteParams,
+  QuoteResponse,
+  QuoteWithDeltaPrice,
+  QuoteWithMarketPrice,
+  QuoteWithMarketPriceAsFallback,
+  //common
+  ConstructFetchInput,
+  ContractCallerFunctions,
+  ConstructProviderFetchInput,
+  // other types
+  GetPartnerFeeFunctions,
+  GetBridgeInfoFunctions,
+  IsTokenSupportedInDeltaFunctions,
+  GetMulticallHandlersFunctions,
+  MulticallHandlersResponse,
+  Token,
+  Address,
+  AddressOrSymbol,
+  PriceString,
+  TxHash,
+  TxSendOverrides,
+  OptimalRate,
+  OptionalRate,
+  FetcherErrorInterface,
+  APIVersion,
+};
+
+export { SDKConfig, constructPartialSDK } from './sdk/partial';
+export { AllSDKMethods, constructFullSDK } from './sdk/full';
+export {
+  SimpleFetchSDK,
+  SimpleSDK,
+  constructSimpleSDK,
+  ProviderOptions as SimpleSDKProviderOptions,
+} from './sdk/simple';
+
+// bundled methods for limitOrders
+export * from './methods/limitOrders';
+export * from './methods/limitOrders/helpers/types';
+// bundled methods for nftOrders
+export * from './methods/nftOrders';
+export * from './methods/nftOrders/helpers/types';
+export { AssetType } from './methods/nftOrders/helpers/misc';

package/src/methods/common/orders/buildOrderData.ts

@@ -0,0 +1,29 @@
+export const name = 'AUGUSTUS RFQ';
+export const version = '1';
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+
+type TypedDataDomain = {
+  name?: string;
+  version?: string;
+  chainId?: bigint | string | number;
+  verifyingContract?: string;
+  salt?: string;
+};
+
+export type TypedDataField = {
+  name: string;
+  type: string;
+};
+
+export type SignableTypedData = {
+  types: Record<string, TypedDataField[]>;
+  domain: TypedDataDomain;
+  data: Record<string, any>;
+};
+
+export type Domain = {
+  name: string;
+  version: string;
+  chainId: number;
+  verifyingContract: string;
+};