@lombard.finance/sdk 0.1.0

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@lombard.finance/sdk",
+  "version": "0.1.0",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./src/index.ts"
+    }
+  },
+  "license": "MIT",
+  "type": "module",
+  "types": "./src/index.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">= 18"
+  },
+  "scripts": {
+    "types": "tsc --noEmit",
+    "build": "yarn types && vite build",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build",
+    "build-docs": "rimraf ./docs && typedoc"
+  },
+  "dependencies": {
+    "@bitcoin-js/tiny-secp256k1-asmjs": "^2.2.3",
+    "bitcoinjs-lib": "^6.1.5"
+  },
+  "peerDependencies": {
+    "axios": "^1",
+    "bignumber.js": "^9",
+    "web3": "^4"
+  },
+  "devDependencies": {
+    "@chromatic-com/storybook": "1.6.1",
+    "@storybook/addon-essentials": "^8.2.9",
+    "@storybook/addon-interactions": "^8.2.9",
+    "@storybook/addon-links": "^8.2.9",
+    "@storybook/addon-onboarding": "^8.2.9",
+    "@storybook/blocks": "^8.2.9",
+    "@storybook/react": "^8.2.9",
+    "@storybook/react-vite": "^8.2.9",
+    "@storybook/test": "^8.2.9",
+    "axios": "^1.7.4",
+    "bignumber.js": "^9.1.2",
+    "bootstrap": "^5.3.3",
+    "rimraf": "^5",
+    "storybook": "^8.2.9",
+    "typedoc": "^0.26.6",
+    "typescript": "^5.4.5",
+    "web3": "^4.11.1"
+  }
+}

package/src/btcSdk/utils/getOutputScript.ts

@@ -0,0 +1,54 @@
+import * as ecc from '@bitcoin-js/tiny-secp256k1-asmjs';
+import {
+  address as addressUtils,
+  initEccLib,
+  networks,
+  payments,
+} from 'bitcoinjs-lib';
+import { OEnv, TEnv } from '../../common/types/types';
+
+initEccLib(ecc);
+
+/**
+ * Get output script from address.
+ *
+ * @param address - The address.
+ * @param networkMode - The network mode.
+ *
+ * @returns The output script.
+ */
+export function getOutputScript(
+  address: string,
+  env: TEnv = OEnv.prod,
+): string {
+  const paymentType = getPaymentType(address);
+
+  const payment = payments[paymentType]({
+    address,
+    network: env === OEnv.prod ? networks.bitcoin : networks.testnet,
+  });
+
+  const paymentOutputScript = payment.output?.toString('hex');
+
+  if (!paymentOutputScript) {
+    throw new Error('Output script is not found.');
+  }
+
+  return `0x${paymentOutputScript}`;
+}
+
+function getPaymentType(address: string): 'p2tr' | 'p2wpkh' {
+  const result = addressUtils.fromBech32(address);
+
+  const isP2TR = result.version === 1 && result.data.length === 32;
+  if (isP2TR) {
+    return 'p2tr';
+  }
+
+  const isP2WPKH = result.version === 0 && result.data.length === 20;
+  if (isP2WPKH) {
+    return 'p2wpkh';
+  }
+
+  throw new Error('Payment type is not supported.');
+}

package/src/common/const.ts

@@ -0,0 +1,3 @@
+import { OEnv, TEnv } from './types/types';
+
+export const defaultEnv: TEnv = OEnv.stage;

package/src/common/types/internalTypes.ts

@@ -0,0 +1,8 @@
+import { TEnv } from './types';
+
+export interface IEnvParam {
+  /**
+   * The environment. Available values are `prod` and `stage`.
+   */
+  env?: TEnv;
+}

package/src/common/types/types.ts

@@ -0,0 +1,13 @@
+export const OEnv = {
+  prod: 'prod',
+  stage: 'stage',
+} as const;
+
+export type TEnv = (typeof OEnv)[keyof typeof OEnv];
+
+export const OChainId = {
+  ethereum: 1,
+  holesky: 17000,
+} as const;
+
+export type TChainId = (typeof OChainId)[keyof typeof OChainId];

package/src/common/utils/convertSatoshi.ts

@@ -0,0 +1,21 @@
+const BTC_DECIMALS = 8;
+const SATOSHI_SCALE = 10 ** BTC_DECIMALS;
+
+/**
+ * Convert Satoshi to BTC
+ * @param amount - Satoshi amount
+ * @returns BTC amount
+ */
+export function fromSatoshi(amount: number | string) {
+  return +amount / SATOSHI_SCALE;
+}
+
+/**
+ * Convert BTC to Satoshi
+ *
+ * @param amount - BTC amount
+ * @returns Satoshi amount
+ */
+export function toSatoshi(amount: number | string) {
+  return Math.floor(+amount * SATOSHI_SCALE);
+}

package/src/common/utils/getErrorMessage.ts

@@ -0,0 +1,35 @@
+import { AxiosError } from 'axios';
+
+/**
+ * Retrieves the error message from the given error object.
+ *
+ * @param error - The error object.
+ * @returns The error message as a string.
+ */
+export function getErrorMessage(error: unknown): string {
+  if (typeof error === 'string') {
+    return error;
+  }
+
+  if (error instanceof Error) {
+    return getAxiosErrorMessage(error as AxiosError);
+  }
+
+  return getErrorMessageFromObject(error);
+}
+
+function getAxiosErrorMessage(error: AxiosError): string {
+  if (error.response) {
+    return (error.response.data as { message: string }).message;
+  }
+
+  return error.message;
+}
+
+function getErrorMessageFromObject(error: any): string {
+  if (error?.message) {
+    return error.message;
+  }
+
+  return 'Unknown error';
+}

package/src/common/utils/isValidChain.ts

@@ -0,0 +1,5 @@
+import { OChainId, TChainId } from '../types/types';
+
+export function isValidChain(chainId: number): chainId is TChainId {
+  return Object.values(OChainId).includes(chainId as TChainId);
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './sdk';
+export * from './web3Sdk';
+
+export * from './common/types/types';
+export * from './common/utils/convertSatoshi';

package/src/provider/Provider.ts

@@ -0,0 +1,174 @@
+import Web3, { Contract, ContractAbi, Transaction, utils } from 'web3';
+import { IReadProviderParams, ReadProvider } from './ReadProvider';
+import {
+  TRpcUrlConfig,
+  rpcUrlConfig as defaultRpcUrlConfig,
+} from './rpcUrlConfig';
+import { ISendOptions, IWeb3SendResult } from './types';
+
+export interface IProviderParams extends IReadProviderParams {
+  /**
+   * The web3 instance with write access.
+   */
+  web3: Web3;
+  /**
+   * The сurrent account address.
+   */
+  account: string;
+}
+
+export class Provider extends ReadProvider {
+  web3: Web3;
+  account: string;
+  rpcConfig: TRpcUrlConfig;
+
+  constructor({ web3, account, chainId, rpcUrlConfig }: IProviderParams) {
+    super({ chainId, rpcUrlConfig });
+    this.web3 = web3;
+    this.account = account;
+    this.chainId = chainId;
+    this.rpcConfig = { ...defaultRpcUrlConfig, ...rpcUrlConfig };
+  }
+
+  /**
+   * Signs a message using the current provider and account.
+   * @public
+   * @param message - The message to be signed.
+   * @returns A promise that resolves to the signed message as a string.
+   */
+  public async signMessage(message: string): Promise<string> {
+    const { account } = this;
+
+    const messageHex = `0x${Buffer.from(message, 'utf8').toString('hex')}`;
+
+    const ethereum = this.web3.currentProvider as any;
+
+    return ethereum.request({
+      method: 'personal_sign',
+      params: [messageHex, account],
+    });
+  }
+
+  /**
+   * Custom replacement for web3js [send](https://docs.web3js.org/libdocs/Contract#send).
+   *
+   * @public
+   * @param {string} from - Address of the sender.
+   * @param {string} to - Address of the recipient.
+   * @param {ISendOptions} sendOptions - Options for sending transaction.
+   * @returns {Promise<IWeb3SendResult>} Promise with transaction hash and receipt promise.
+   */
+  public async sendTransactionAsync(
+    from: string,
+    to: string,
+    sendOptions: ISendOptions,
+  ): Promise<IWeb3SendResult> {
+    const { chainId, web3: web3Write } = this;
+    const web3Read = this.getReadWeb3();
+
+    const {
+      data,
+      estimate = false,
+      estimateFee = false,
+      extendedGasLimit,
+      gasLimit = '0',
+      value = '0',
+      gasLimitMultiplier = 1,
+    } = sendOptions;
+    let { nonce } = sendOptions;
+
+    if (!nonce) {
+      nonce = await web3Read.eth.getTransactionCount(from);
+    }
+
+    console.log(`Nonce: ${nonce}`);
+
+    const tx: Transaction = {
+      from,
+      to,
+      value: utils.numberToHex(value),
+      gas: utils.numberToHex(gasLimit),
+      data,
+      nonce,
+      chainId: utils.numberToHex(chainId),
+    };
+
+    if (estimate) {
+      try {
+        const estimatedGas = await web3Read.eth.estimateGas(tx);
+        const multipliedGasLimit = Math.round(
+          Number(estimatedGas) * gasLimitMultiplier,
+        );
+
+        if (extendedGasLimit) {
+          tx.gas = utils.numberToHex(multipliedGasLimit + extendedGasLimit);
+        } else {
+          tx.gas = utils.numberToHex(multipliedGasLimit);
+        }
+      } catch (e) {
+        throw new Error(
+          (e as Partial<Error>).message ??
+            'Failed to estimate gas limit for transaction.',
+        );
+      }
+    }
+
+    const { maxFeePerGas, maxPriorityFeePerGas } = estimateFee
+      ? await this.getMaxFees().catch(() => sendOptions)
+      : sendOptions;
+
+    if (maxPriorityFeePerGas !== undefined) {
+      tx.maxPriorityFeePerGas = utils.numberToHex(maxPriorityFeePerGas);
+    }
+
+    if (maxFeePerGas !== undefined) {
+      tx.maxFeePerGas = utils.numberToHex(maxFeePerGas);
+    }
+
+    if (!tx.maxFeePerGas && !tx.maxPriorityFeePerGas) {
+      const safeGasPrice = await this.getSafeGasPriceWei();
+      tx.gasPrice = safeGasPrice.toString(10);
+    }
+
+    if (!tx.maxFeePerGas && !tx.maxPriorityFeePerGas) {
+      const safeGasPrice = await this.getSafeGasPriceWei();
+      tx.gasPrice = safeGasPrice.toString(10);
+    }
+
+    console.log('Sending transaction via Web3: ', tx);
+
+    return new Promise((resolve, reject) => {
+      const promise = web3Write.eth.sendTransaction(tx);
+
+      promise
+        .once('transactionHash', async (transactionHash: string) => {
+          console.log(`Just signed transaction has is: ${transactionHash}`);
+
+          const rawTx = await web3Read.eth.getTransaction(transactionHash);
+
+          console.log(
+            'Found transaction in node: ',
+            JSON.stringify(
+              rawTx,
+              (_, value) =>
+                typeof value === 'bigint' ? value.toString() : value,
+              2,
+            ),
+          );
+
+          resolve({
+            receiptPromise: promise,
+            transactionHash,
+          });
+        })
+        .catch(reject);
+    });
+  }
+
+  public createContract<AbiType extends ContractAbi>(
+    abi: any,
+    address: string,
+  ): Contract<AbiType> {
+    return new this.web3.eth.Contract<AbiType>(abi, address);
+  }
+}

package/src/provider/ReadProvider.ts

@@ -0,0 +1,120 @@
+import BigNumber from 'bignumber.js';
+import Web3, { Contract, ContractAbi } from 'web3';
+import {
+  TRpcUrlConfig,
+  rpcUrlConfig as defaultRpcUrlConfig,
+} from './rpcUrlConfig';
+import { IGetMaxFeesResult } from './types';
+import { getMaxPriorityFeePerGas } from './utils/getMaxPriorityFeePerGas';
+
+const FEE_MULTIPLIER = 2;
+const ADDITIONAL_SAFE_GAS_PRICE_WEI = 25_000;
+
+export interface IReadProviderParams {
+  chainId: number;
+  /**
+   * The RPC URL configuration. If not provided, the default configuration will be used.
+   */
+  rpcUrlConfig?: TRpcUrlConfig;
+}
+
+export class ReadProvider {
+  chainId: number;
+  rpcConfig: TRpcUrlConfig;
+
+  constructor({ chainId, rpcUrlConfig }: IReadProviderParams) {
+    this.chainId = chainId;
+    this.rpcConfig = { ...defaultRpcUrlConfig, ...rpcUrlConfig };
+  }
+
+  /**
+   * Returns web3 instance for read operations.
+   *
+   * @public
+   * @returns {Web3} Web3 instance.
+   */
+  public getReadWeb3(): Web3 {
+    const rpcUrl = this.getRpcUrl();
+    const readWeb3 = new Web3();
+    const provider = new Web3.providers.HttpProvider(rpcUrl);
+    readWeb3.setProvider(provider);
+    return readWeb3;
+  }
+
+  /**
+   * Retrieves the RPC URL based on the current chain ID.
+   * @returns The RPC URL for the current chain ID.
+   * @throws Error if the RPC URL for the current chain ID is not found.
+   */
+  getRpcUrl(): string {
+    const { chainId } = this;
+    const rpcUrl = this.rpcConfig?.[chainId];
+
+    if (!rpcUrl) {
+      throw new Error(`RPC URL for chainId ${chainId} not found`);
+    }
+
+    return rpcUrl;
+  }
+
+  /**
+   * Calculates max fees for transaction. Thess values are available for networks
+   * with EIP-1559 support.
+   *
+   * @public
+   * @note If current network is Binance Smart Chain, will return default values.
+   * @returns {Promise<IGetMaxFeesResult>} Max fees for transaction.
+   */
+  public async getMaxFees(): Promise<IGetMaxFeesResult> {
+    const web3 = this.getReadWeb3();
+    const rpcUrl = this.getRpcUrl();
+
+    const [block, maxPriorityFeePerGas] = await Promise.all([
+      web3.eth.getBlock('latest'),
+      getMaxPriorityFeePerGas(rpcUrl),
+    ]);
+
+    if (!block?.baseFeePerGas && typeof block?.baseFeePerGas !== 'bigint') {
+      return {};
+    }
+
+    const maxFeePerGas = new BigNumber(block.baseFeePerGas.toString(10))
+      .multipliedBy(FEE_MULTIPLIER)
+      .plus(maxPriorityFeePerGas);
+
+    return {
+      maxFeePerGas: +maxFeePerGas,
+      maxPriorityFeePerGas: +maxPriorityFeePerGas,
+    };
+  }
+
+  /**
+   * Returns safe gas price for transaction.
+   *
+   * @public
+   * @returns {Promise<BigNumber>} Safe gas price.
+   */
+  public async getSafeGasPriceWei(): Promise<BigNumber> {
+    const pureGasPriceWei = await this.getReadWeb3().eth.getGasPrice();
+
+    return new BigNumber(pureGasPriceWei.toString(10)).plus(
+      ADDITIONAL_SAFE_GAS_PRICE_WEI,
+    );
+  }
+
+  /**
+   * Creates a contract instance with the given ABI and address.
+   *
+   * @template AbiType - The type of the contract ABI.
+   * @param {any} abi - The ABI of the contract.
+   * @param {string} address - The address of the contract.
+   * @returns {Contract<AbiType>} The contract instance.
+   */
+  public createContract<AbiType extends ContractAbi>(
+    abi: any,
+    address: string,
+  ): Contract<AbiType> {
+    const web3 = this.getReadWeb3();
+    return new web3.eth.Contract<AbiType>(abi, address);
+  }
+}

package/src/provider/index.ts

@@ -0,0 +1,2 @@
+export * from './Provider';
+export * from './types';

package/src/provider/rpcUrlConfig.ts

@@ -0,0 +1,8 @@
+import { OChainId } from '../common/types/types';
+
+export type TRpcUrlConfig = Record<number, string>;
+
+export const rpcUrlConfig: TRpcUrlConfig = {
+  [OChainId.ethereum]: 'https://eth.llamarpc.com',
+  [OChainId.holesky]: 'https://ethereum-holesky-rpc.publicnode.com',
+};

package/src/provider/types.ts

@@ -0,0 +1,58 @@
+import { core, eth, FMT_BYTES, FMT_NUMBER, TransactionReceipt } from 'web3';
+
+export interface IGetMaxFeesResult {
+  maxPriorityFeePerGas?: number;
+  maxFeePerGas?: number;
+}
+
+export type PromiEvent<T> = core.Web3PromiEvent<
+  T,
+  eth.SendTransactionEvents<{
+    readonly number: FMT_NUMBER.BIGINT;
+    readonly bytes: FMT_BYTES.HEX;
+  }>
+>;
+
+export interface IWeb3SendResult {
+  receiptPromise: PromiEvent<TransactionReceipt>;
+  transactionHash: string;
+}
+
+export interface ISendOptions {
+  /**
+   * Txn data.
+   */
+  data?: string;
+  /**
+   * Gas limit for transaction.
+   * @note When `estimate` is `true`, this value will redefined by estimated gas limit.
+   */
+  gasLimit?: string;
+  /**
+   * Multiplier for gas limit when estimating gas.
+   * When specified, gas limit will be calculated as `gasLimit * gasLimitMultiplier`.
+   * @note works only when `estimate` is `true`.
+   * @default 1
+   */
+  gasLimitMultiplier?: number;
+  value?: string;
+  /**
+   * When `true`, will estimate gas limit for transaction.
+   * @note `gasLimit` option will be redefined by estimated gas limit.
+   */
+  estimate?: boolean;
+  /**
+   * When `true`, will estimate max fees for transaction.
+   * @note `maxPriorityFeePerGas` and `maxFeePerGas` options will be redefined by estimated values.
+   * @note Please use only for networks with EIP-1559 support.
+   */
+  estimateFee?: boolean;
+  nonce?: bigint;
+  /**
+   * Additional gas limit for transaction.
+   * @note When `estimate` is `true`, this value will be added to estimated gas limit.
+   */
+  extendedGasLimit?: number;
+  maxPriorityFeePerGas?: number;
+  maxFeePerGas?: number;
+}

package/src/provider/utils/getMaxPriorityFeePerGas.ts

@@ -0,0 +1,25 @@
+import BigNumber from 'bignumber.js';
+import Web3 from 'web3';
+
+export async function getMaxPriorityFeePerGas(
+  rpcUrl: string,
+): Promise<BigNumber> {
+  const response = await fetch(rpcUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'eth_maxPriorityFeePerGas',
+      params: [],
+    }),
+  });
+
+  const data = await response.json();
+
+  const convertedHexValue = Web3.utils.hexToNumber(data?.result);
+
+  return new BigNumber(Number(convertedHexValue));
+}

package/src/sdk/apiConfig.ts

@@ -0,0 +1,20 @@
+import { defaultEnv } from '../common/const';
+import { TEnv } from '../common/types/types';
+
+interface IApiConfig {
+  depositAddrApiUrl: string;
+  baseApiUrl: string;
+}
+
+const stageConfig: IApiConfig = {
+  depositAddrApiUrl: 'https://staging.prod.lombard.finance',
+  baseApiUrl: 'https://staging.prod.lombard.finance',
+};
+
+const prodConfig: IApiConfig = {
+  depositAddrApiUrl: 'https://consortium.lombard.finance',
+  baseApiUrl: 'https://mainnet.prod.lombard.finance',
+};
+
+export const getApiConfig = (env: TEnv = defaultEnv): IApiConfig =>
+  env === 'prod' ? prodConfig : stageConfig;

package/src/sdk/generateDepositBtcAddress/generateDepositBtcAddress.stories.tsx

@@ -0,0 +1,52 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { defaultEnv } from '../../common/const';
+import { OChainId } from '../../common/types/types';
+import { Button } from '../../stories/components/Button';
+import { CodeBlock } from '../../stories/components/CodeBlock';
+import { exampleEvmAddress } from '../../stories/const';
+import useQuery from '../../stories/hooks/useQuery';
+import { fromCamelCase } from '../../stories/utils/fromCamelCase';
+import {
+  generateDepositBtcAddress,
+  IGenerateDepositBtcAddressParams,
+} from './generateDepositBtcAddress';
+
+const { name } = generateDepositBtcAddress;
+const nameWithWhitespaces = fromCamelCase(name);
+
+const meta = {
+  title: 'SDK/generateDepositBtcAddress',
+  component: StoryView,
+  tags: ['autodocs'],
+} satisfies Meta<typeof StoryView>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const WithParams: Story = {
+  args: {
+    address: exampleEvmAddress,
+    chainId: OChainId.ethereum,
+    signature: '',
+    env: defaultEnv,
+  },
+};
+
+export function StoryView(props: IGenerateDepositBtcAddressParams) {
+  const { data, error, isLoading, refetch } = useQuery(
+    () => generateDepositBtcAddress(props),
+    [props],
+    false,
+  );
+
+  return (
+    <>
+      <Button onClick={refetch} disabled={isLoading} isLoading={isLoading}>
+        {nameWithWhitespaces}
+      </Button>
+
+      <CodeBlock text={error || data} />
+    </>
+  );
+}