@velora-dex/sdk 8.0.0

package/src/helpers/misc.ts

@@ -0,0 +1,160 @@
+import type { Primitive } from 'ts-essentials';
+
+export const objectToFilledEntries = <T extends Record<string, unknown>>(
+  object: T
+): [string, string][] => {
+  return (
+    Object.entries(object)
+      // removes keys with undefined values
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => [key, String(value)])
+  );
+};
+
+export const constructSearchString = <
+  //                               not arrays or mappings
+  U extends Record<string, Exclude<Primitive, symbol>>
+>(
+  queryOptions: U
+): `?${string}` | '' => {
+  const queryEntries = objectToFilledEntries(queryOptions);
+
+  const queryString = new URLSearchParams(queryEntries).toString();
+
+  // returns empty string or `?${string}`
+  return queryString && `?${queryString}`;
+};
+
+type MinAxiosError = {
+  code?: string;
+  request?: any;
+  isAxiosError: boolean;
+  message: string;
+};
+
+type MinAxiosResponse = {
+  data: any;
+  status: number;
+  statusText: string;
+  headers: Record<string, any>;
+  config: { url?: string; method?: string };
+};
+
+type FetcherErrorConstructorInput = MinAxiosError & {
+  response?: MinAxiosResponse;
+};
+
+export interface FetcherErrorInterface extends FetcherErrorConstructorInput {
+  status?: number;
+  code?: string;
+}
+
+export const isFetcherError = (error: unknown): error is FetcherError => {
+  return error instanceof FetcherError;
+};
+
+export class FetcherError extends Error implements FetcherErrorInterface {
+  code;
+  status;
+  request;
+  response;
+  isAxiosError = false;
+
+  public constructor({
+    code,
+    request,
+    response,
+    isAxiosError,
+    message,
+  }: FetcherErrorConstructorInput) {
+    super();
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, FetcherError);
+    }
+
+    this.name = this.constructor.name;
+    this.code = code;
+    this.request = request;
+    this.isAxiosError = isAxiosError;
+
+    // no response on AxiosError
+    if (!response) {
+      this.message = message;
+      return;
+    }
+
+    this.response = response;
+
+    const { data, status } = response;
+    this.status = status;
+    this.message = isDataWithError(data) ? data.error : message;
+  }
+}
+// to turn `object -> Record` for indexed variable access
+function isObject(obj: unknown): obj is Record<string | symbol, any> {
+  return !!obj && typeof obj === 'object';
+}
+
+export function isDataWithError(data: unknown): data is { error: string } {
+  return isObject(data) && typeof data['error'] === 'string';
+}
+
+export type ExtractAbiMethodNames<T extends readonly { name: string }[]> =
+  T[number]['name'];
+
+// reduce element[] to Object{key: prop, val?: element}
+// for example
+// gatherObjectsByProp(Token[], token => token.address) => Record<address, Token|undefined>
+export function gatherObjectsByProp<T>(
+  elements: T[],
+  pickProp: (elem: T, index: number) => string
+): Record<string, T>;
+export function gatherObjectsByProp<T, U>(
+  elements: T[],
+  pickProp: (elem: T, index: number) => string,
+  transfrom: (elem: T, accumElem: U | undefined, index: number) => U
+): Record<string, U>;
+export function gatherObjectsByProp<T, U>(
+  elements: T[],
+  pickProp: (elem: T, index: number) => string,
+  transform?: (elem: T, accumElem: U | undefined, index: number) => U
+): Record<string, T> | Record<string, U> {
+  return elements.reduce<Record<string, T> | Record<string, U>>(
+    (accum, element, index) => {
+      const key = pickProp(element, index);
+
+      const accumElem: T | U | undefined = accum[key];
+      const transformedElement = transform
+        ? //                       if transform is available, can only be U | undefined
+          transform(element, accumElem as U | undefined, index)
+        : element;
+
+      accum[key] = transformedElement;
+
+      return accum;
+    },
+    {}
+  );
+}
+
+// checks that array has at least one element
+export const isFilledArray = <T>(array: T[]): array is [T, ...T[]] => {
+  return array.length > 0;
+};
+
+export function getRandomInt(): number {
+  return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+}
+
+export function runOnceAndCache<T, Args extends any[]>(
+  // can pass `(...any[]) => any but null | undefined`
+  func: (...args: Args) => NonNullable<T>
+): (...args: Args) => NonNullable<T> {
+  let result: NonNullable<T>;
+
+  return (...args) => {
+    return result ?? (result = func(...args));
+  };
+}

package/src/helpers/providers/ethers.ts

@@ -0,0 +1,192 @@
+import type {
+  Address,
+  ContractCallerFunctions,
+  NoExtraKeysCheck,
+  SignTypedDataContractCallerFn,
+  StaticContractCallerFn,
+  TransactionContractCallerFn,
+} from '../../types';
+import type {
+  JsonRpcProvider,
+  BaseProvider,
+  JsonRpcSigner,
+} from '@ethersproject/providers';
+import type { Signer } from '@ethersproject/abstract-signer';
+import type {
+  Contract as EthersV5Contract,
+  ContractFunction as EthersContractFunctionV5,
+  PopulatedTransaction as EthersPopulatedTransactionV5,
+  PayableOverrides,
+  CallOverrides,
+  ContractTransaction,
+} from '@ethersproject/contracts';
+
+import type { BigNumber as EthersBigNumberV5 } from '@ethersproject/bignumber';
+
+import { assert } from 'ts-essentials';
+
+export interface EthersV5ProviderDeps {
+  ethersProviderOrSigner: BaseProvider | Signer;
+  EthersContract: typeof EthersV5Contract; // passing Contract in allows not to include ethers as dependency
+}
+
+export const constructEthersV5ContractCaller = (
+  {
+    ethersProviderOrSigner: providerOrSigner,
+    EthersContract: Contract,
+  }: EthersV5ProviderDeps,
+  account?: Address
+): ContractCallerFunctions<ContractTransaction> => {
+  const staticCall: StaticContractCallerFn = async (params) => {
+    const { address, abi, contractMethod, args, overrides } = params;
+
+    const contract = new Contract(address, abi, providerOrSigner);
+
+    assertEthersContractHasMethodsV5(contract, contractMethod);
+    // drop keys not in CallOverrides
+    const { block, gas, ...restOverrides } = overrides;
+    // reassign values to keys in CallOverrides
+    const normalizedOverrides = {
+      ...restOverrides,
+      blockTag: block,
+      gasLimit: gas,
+    };
+
+    // type FinalCallOverrides = normalizedOverrides has extra props ? never : normalizedOverrides
+    type FinalCallOverrides = NoExtraKeysCheck<
+      typeof normalizedOverrides,
+      CallOverrides
+    >;
+
+    // enforce overrides shape ethers accepts
+    // TS will break if normalizedOverrides type has any keys not also present in CallOverrides
+    const callOverrides: FinalCallOverrides = normalizedOverrides;
+    // returns whatever the Contract.method returns: BigNumber, string, boolean
+    return contract.callStatic[contractMethod](...args, callOverrides);
+  };
+
+  const transactCall: TransactionContractCallerFn<ContractTransaction> = async (
+    params
+  ) => {
+    assert(account, 'account must be specified to create a signer');
+    assert(
+      isEthersProviderWithSigner(providerOrSigner) ||
+        isEthersSigner(providerOrSigner),
+      'ethers must be an instance of Signer or JsonRpcProvider to create a signer'
+    );
+
+    const { address, abi, contractMethod, args, overrides } = params;
+
+    const signer =
+      'getSigner' in providerOrSigner
+        ? providerOrSigner.getSigner(account)
+        : providerOrSigner;
+
+    const contract = new Contract(address, abi, signer);
+
+    assertEthersContractHasMethodsV5(contract, contractMethod);
+    // drop keys not in PayableOverrides
+    const { gas, from, ...restOverrides } = overrides;
+    // reassign values to keys in PayableOverrides
+    const normalizedOverrides = {
+      ...restOverrides,
+      gasLimit: gas,
+    };
+
+    // type FinalPayableOverrides = normalizedOverrides has extra props ? never : normalizedOverrides
+    type FinalPayableOverrides = NoExtraKeysCheck<
+      typeof normalizedOverrides,
+      PayableOverrides
+    >;
+
+    // enforce overrides shape ethers accepts
+    // TS will break if normalizedOverrides type has any keys not also present in PayableOverrides
+    const txOverrides: FinalPayableOverrides = normalizedOverrides;
+    const txResponse: ContractTransaction = await contract[contractMethod](
+      ...args,
+      txOverrides
+    );
+
+    return txResponse;
+  };
+
+  const signTypedDataCall: SignTypedDataContractCallerFn = async (
+    typedData
+  ) => {
+    assert(account, 'account must be specified to create a signer');
+    assert(
+      isEthersProviderWithSigner(providerOrSigner) ||
+        isEthersSigner(providerOrSigner),
+      'ethers must be an instance of Signer or JsonRpcProvider to create a signer'
+    );
+
+    const signer =
+      'getSigner' in providerOrSigner
+        ? providerOrSigner.getSigner(account)
+        : providerOrSigner;
+
+    assert(isTypedDataCapableSigner(signer), 'Signer can sign typed data');
+
+    const { data, domain, types } = typedData;
+
+    return signer._signTypedData(domain, types, data);
+  };
+
+  return { staticCall, transactCall, signTypedDataCall };
+};
+
+function isEthersProvider(
+  providerOrSigner: BaseProvider | Signer
+): providerOrSigner is BaseProvider {
+  return '_isProvider' in providerOrSigner && providerOrSigner._isProvider;
+}
+
+function isEthersProviderWithSigner(
+  providerOrSigner: JsonRpcProvider | BaseProvider | Signer
+): providerOrSigner is JsonRpcProvider {
+  return isEthersProvider(providerOrSigner) && 'getSigner' in providerOrSigner;
+}
+
+function isEthersSigner(
+  providerOrSigner: BaseProvider | Signer
+): providerOrSigner is Signer {
+  return '_isSigner' in providerOrSigner && providerOrSigner._isSigner;
+}
+
+function isTypedDataCapableSigner(
+  signer: Signer
+): signer is Signer & Pick<JsonRpcSigner, '_signTypedData'> {
+  return '_signTypedData' in signer;
+}
+
+/// ethers v5
+type EthersContractWithMethodV5<T extends string> = EthersV5Contract & {
+  readonly [method in T]: EthersContractFunctionV5;
+} & {
+  readonly functions: { [method in T]: EthersContractFunctionV5 };
+
+  readonly callStatic: { [method in T]: EthersContractFunctionV5 };
+  readonly estimateGas: {
+    [method in T]: EthersContractFunctionV5<EthersBigNumberV5>;
+  };
+  readonly populateTransaction: {
+    [method in T]: EthersContractFunctionV5<EthersPopulatedTransactionV5>;
+  };
+};
+
+function ethersContractHasMethodsV5<T extends string>(
+  contract: EthersV5Contract,
+  ...methods: T[]
+): contract is EthersContractWithMethodV5<T> {
+  return methods.every((method) => typeof contract[method] === 'function');
+}
+
+function assertEthersContractHasMethodsV5<T extends string>(
+  contract: EthersV5Contract,
+  ...methods: T[]
+): asserts contract is EthersContractWithMethodV5<T> {
+  assert(
+    ethersContractHasMethodsV5(contract, ...methods),
+    `Contract must have methods: ${methods.join(', ')}`
+  );
+}

package/src/helpers/providers/ethersV6.ts

@@ -0,0 +1,121 @@
+import type {
+  Address,
+  ContractCallerFunctions,
+  SignTypedDataContractCallerFn,
+  StaticContractCallerFn,
+  TransactionContractCallerFn,
+} from '../../types';
+import { assert } from 'ts-essentials';
+import type {
+  JsonRpcProvider,
+  Signer,
+  ContractRunner,
+  Contract as EthersContract,
+  Overrides,
+  ContractTransactionResponse,
+} from 'ethers';
+
+export interface EthersV6ProviderDeps {
+  ethersV6ProviderOrSigner: ContractRunner | Signer;
+  EthersV6Contract: typeof EthersContract; // passing Contract in allows not to include ethers as dependency
+}
+
+export const constructContractCaller = (
+  {
+    ethersV6ProviderOrSigner: providerOrSigner,
+    EthersV6Contract: Contract,
+  }: EthersV6ProviderDeps,
+  account?: Address
+): ContractCallerFunctions<ContractTransactionResponse> => {
+  const staticCall: StaticContractCallerFn = async (params) => {
+    const { address, abi, contractMethod, args, overrides } = params;
+
+    const contract = new Contract(address, abi, providerOrSigner);
+
+    // drop keys not in CallOverrides
+    const { block, gas, ...restOverrides } = overrides;
+    // reassign values to keys in CallOverrides
+    const normalizedOverrides: Overrides = {
+      ...restOverrides,
+      blockTag: block,
+      gasLimit: gas,
+    };
+
+    const callableContractFunction = contract.getFunction(contractMethod);
+
+    // returns whatever the Contract["method"].staticCall returns: BigNumber, string, boolean
+    return callableContractFunction.staticCall(...args, normalizedOverrides);
+  };
+
+  const transactCall: TransactionContractCallerFn<
+    ContractTransactionResponse
+  > = async (params) => {
+    assert(account, 'account must be specified to create a signer');
+    assert(
+      isEthersProviderWithSigner(providerOrSigner) ||
+        isEthersSigner(providerOrSigner),
+      'ethers must be an instance of Signer or JsonRpcProvider to create a signer'
+    );
+
+    const { address, abi, contractMethod, args, overrides } = params;
+
+    const signer =
+      'getSigner' in providerOrSigner
+        ? await providerOrSigner.getSigner(account)
+        : providerOrSigner;
+
+    const contract = new Contract(address, abi, signer);
+
+    // drop keys not in PayableOverrides
+    const { gas, from, ...restOverrides } = overrides;
+    // reassign values to keys in PayableOverrides
+    const normalizedOverrides: Overrides = {
+      ...restOverrides,
+      gasLimit: gas,
+    };
+
+    // if no method for contractMethod, ethers will throw
+    const callableContractFunction = contract.getFunction(contractMethod);
+
+    const txResponse = await callableContractFunction.send(
+      ...args,
+      normalizedOverrides
+    );
+
+    return txResponse;
+  };
+
+  const signTypedDataCall: SignTypedDataContractCallerFn = async (
+    typedData
+  ) => {
+    assert(account, 'account must be specified to create a signer');
+    assert(
+      isEthersProviderWithSigner(providerOrSigner) ||
+        isEthersSigner(providerOrSigner),
+      'ethers must be an instance of Signer or JsonRpcProvider to create a signer'
+    );
+
+    const signer =
+      'getSigner' in providerOrSigner
+        ? await providerOrSigner.getSigner(account)
+        : providerOrSigner;
+
+    const { data, domain, types } = typedData;
+
+    return signer.signTypedData(domain, types, data);
+  };
+
+  return { staticCall, transactCall, signTypedDataCall };
+};
+
+function isEthersProviderWithSigner(
+  providerOrSigner: JsonRpcProvider | ContractRunner | Signer
+): providerOrSigner is JsonRpcProvider {
+  return 'getSigner' in providerOrSigner;
+}
+
+function isEthersSigner(
+  providerOrSigner: ContractRunner | Signer
+): providerOrSigner is Signer {
+  return 'getAddress' in providerOrSigner;
+}

package/src/helpers/providers/helpers.ts

@@ -0,0 +1,36 @@
+import { assert } from 'ts-essentials';
+import { TypedDataField } from '../../methods/common/orders/buildOrderData';
+
+// regex from @ethersproject/hash TypedDataEncoder.constructor
+// may be overly strict, but reliable
+const baseTypeRegex = /^([^\x5b]*)(\x5b|$)/;
+
+export function findPrimaryType(
+  types: Record<string, TypedDataField[]>
+): string {
+  const candidates = Object.keys(types);
+  const candidatesSet = new Set(candidates);
+
+  candidates.forEach((candidate) => {
+    const typedDataFields = types[candidate];
+    if (!typedDataFields) return;
+
+    typedDataFields.forEach(({ type }) => {
+      // Get the base type (drop any array specifiers)
+      const baseType = type.match(baseTypeRegex)?.[1];
+      if (!baseType) return;
+
+      // if type was referred to as a child of another type, it can't be the primaryType
+      candidatesSet.delete(baseType);
+    });
+  });
+
+  const [primaryType] = Array.from(candidatesSet);
+
+  assert(
+    primaryType,
+    `No primary type found in SignableTypedData types, ${JSON.stringify(types)}`
+  );
+
+  return primaryType;
+}

package/src/helpers/providers/viem.ts

@@ -0,0 +1,205 @@
+import type {
+  Address,
+  ContractCallerFunctions,
+  ContractCallStaticInput,
+  SignTypedDataContractCallerFn,
+  StaticContractCallerFn,
+  TransactionContractCallerFn,
+} from '../../types';
+import { assert, MarkOptional } from 'ts-essentials';
+
+import type {
+  PublicActions,
+  WalletActions,
+  Hex,
+  BlockTag,
+  Chain,
+  Transport,
+  TypedDataDomain,
+  Account,
+} from 'viem';
+import { findPrimaryType } from './helpers';
+import { TransactionParams } from '../../methods/swap/transaction';
+
+export type MinViemClient = Partial<
+  Pick<PublicActions<Transport, Chain>, 'readContract'> &
+    Pick<WalletActions<Chain>, 'writeContract' | 'signTypedData'>
+> & { account?: Account };
+
+export const constructContractCaller = (
+  viemClient: MinViemClient,
+  account?: Address
+): ContractCallerFunctions<Hex> => {
+  const staticCall: StaticContractCallerFn = async <
+    T,
+    M extends string = string
+  >(
+    params: ContractCallStaticInput<M>
+  ): Promise<T> => {
+    assert(
+      viemClient.readContract,
+      'Viem client must have readContract Public Action'
+    );
+    const { address, abi, contractMethod, args, overrides } = params;
+
+    const { block } = overrides;
+
+    const { blockNumber, blockTag } =
+      typeof block === 'number'
+        ? { blockNumber: BigInt(block) }
+        : { blockTag: block as BlockTag };
+
+    const result = viemClient.readContract({
+      account: viemClient.account || (account as Hex),
+      address: address as Hex,
+      abi,
+      functionName: contractMethod,
+      args,
+      blockTag,
+      blockNumber,
+    });
+
+    return result as T; // can't get specific type for generic abi & method
+  };
+
+  const transactCall: TransactionContractCallerFn<Hex> = async (params) => {
+    assert(account, 'account must be specified sign transactions');
+    assert(
+      viemClient.writeContract,
+      'Viem client must have writeContract Wallet Action'
+    );
+
+    const { address, abi, contractMethod, args, overrides } = params;
+
+    const viemTxParams = txParamsToViemTxParams({
+      ...overrides,
+      to: address,
+      gas: overrides.gas?.toString(10),
+      value: overrides.value?.toString(10),
+    });
+
+    const gasPriceParams =
+      'maxFeePerGas' in viemTxParams
+        ? {
+            maxFeePerGas: viemTxParams.maxFeePerGas,
+            maxPriorityFeePerGas: viemTxParams.maxPriorityFeePerGas,
+          }
+        : 'gasPrice' in viemTxParams
+        ? { gasPrice: viemTxParams.gasPrice }
+        : {};
+
+    const txHash = await viemClient.writeContract({
+      // either `viemClient` has account assigned to it,
+      // or the provider `viemClient` was created with must control `account` (viemClient.getAddresses()[0]===account);
+      // otherwise breaks with ` ProviderError: Unknown account 0x...`
+      account: viemClient.account || (account as Hex),
+      address: address as Hex,
+      abi,
+      functionName: contractMethod,
+      args: argsToViemArgs(args),
+      value: viemTxParams.value,
+      gas: viemTxParams.gas,
+      // ...viemTxParams,
+      // account: (overrides.from || account) as Hex,
+      nonce: overrides.nonce,
+      ...gasPriceParams,
+    });
+
+    return txHash;
+  };
+
+  const signTypedDataCall: SignTypedDataContractCallerFn = async (
+    typedData
+  ) => {
+    assert(account, 'account must be specified to create a signer');
+    assert(
+      viemClient.signTypedData,
+      'Viem client must have signTypedData Wallet Action'
+    );
+
+    const { data, domain, types } = typedData;
+
+    const primaryType = findPrimaryType(types);
+
+    const chainId =
+      domain.chainId === undefined ? undefined : Number(domain.chainId);
+    const viemDomain: TypedDataDomain = {
+      chainId,
+      name: domain.name,
+      version: domain.version,
+      verifyingContract: domain.verifyingContract as Hex,
+      salt: domain.salt as Hex,
+    };
+
+    const signature = await viemClient.signTypedData({
+      // either `viemClient` has account assigned to it,
+      // or the provider `viemClient` was created with must control `account` (viemClient.getAddresses()[0]===account)
+      account: viemClient.account || (account as Hex),
+      domain: viemDomain,
+      types,
+      primaryType,
+      message: data,
+    });
+
+    return signature;
+  };
+
+  return { staticCall, transactCall, signTypedDataCall };
+};
+
+type ViemTxParams = {
+  to: Hex;
+  data?: Hex;
+  value?: bigint;
+  nonce?: number;
+  gas?: bigint;
+} & (
+  | { maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint }
+  | { gasPrice?: bigint }
+);
+
+export function txParamsToViemTxParams(
+  txParams: Omit<
+    MarkOptional<TransactionParams, 'data' | 'value'>,
+    'chainId' | 'from'
+  >
+): ViemTxParams {
+  const gas = txParams.gas !== undefined ? BigInt(txParams.gas) : undefined;
+  const gasPrice =
+    txParams.gasPrice !== undefined ? BigInt(txParams.gasPrice) : undefined;
+  const maxFeePerGas =
+    txParams.maxFeePerGas !== undefined
+      ? BigInt(txParams.maxFeePerGas)
+      : undefined;
+  const maxPriorityFeePerGas =
+    txParams.maxPriorityFeePerGas !== undefined
+      ? BigInt(txParams.maxPriorityFeePerGas)
+      : undefined;
+
+  const viemTxParams = {
+    to: txParams.to as Hex,
+    data: txParams.data as Hex,
+    value: txParams.value !== undefined ? BigInt(txParams.value) : undefined,
+    gas,
+    ...(txParams.maxFeePerGas !== undefined
+      ? { maxFeePerGas, maxPriorityFeePerGas }
+      : { gasPrice }),
+  };
+  return viemTxParams;
+}
+
+function argsToViemArgs(args: any[]): any[] {
+  return args.map((arg) => {
+    if (typeof arg === 'string') {
+      if (arg.startsWith('0x')) {
+        return arg;
+      }
+      const asNumber = Number(arg);
+      if (Number.isNaN(asNumber)) {
+        return arg;
+      }
+      return BigInt(asNumber);
+    }
+    return arg;
+  });
+}