@lombard.finance/sdk 3.6.8 → 3.6.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lombard.finance/sdk",
-  "version": "3.6.8",
+  "version": "3.6.10",
   "dependencies": {
     "@lombard.finance/sdk-common": "^3.0.0",
     "viem": "^2.23.15",
@@ -25,6 +25,7 @@
     "storybook": "^8.2.9",
     "typedoc": "^0.26.6",
     "typescript": "^5.4.5",
+    "vitest": "^3.2.4",
     "wagmi": "^2.14.15"
   },
   "engines": {
@@ -39,10 +40,7 @@
     "./clients/*": "./src/clients/*.ts",
     "./utils/*": "./src/utils/*.ts"
   },
-  "files": [
-    "dist",
-    "src"
-  ],
+  "files": ["dist", "src"],
   "license": "MIT",
   "peerDependencies": {
     "@layerzerolabs/lz-v2-utilities": "3.0.17",
@@ -57,9 +55,10 @@
     "format": "biome format",
     "lint": "biome lint --diagnostic-level=error",
     "storybook": "storybook dev -p 6006",
+    "test": "vitest run",
     "types": "tsc --noEmit",
     "watch": "vite build --watch"
   },
   "type": "module",
   "types": "./src/index.ts"
-}
+}

package/src/api-functions/getDepositBtcAddress/getDepositBtcAddress.stories.tsx

@@ -8,10 +8,8 @@ import { functionType } from '../../stories/components/decorators';
 import { EXAMPLE_EVM_ADDRESS } from '../../stories/constants';
 import useQuery from '../../stories/hooks/useQuery';
 import { Token } from '../../tokens/token-addresses';
-import {
-  IGetDepositBtcAddressParameters,
-  getDepositBtcAddress,
-} from './getDepositBtcAddress';
+import { getDepositBtcAddress } from './getDepositBtcAddress';
+import { IGetDepositBtcAddressParameters } from './types';
 
 const meta = {
   title: 'api/getDepositBtcAddress',

package/src/api-functions/getDepositBtcAddress/getDepositBtcAddress.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, it, type Mock, vi } from 'vitest';
+vi.mock('./make-request', async () => {
+  return {
+    makeRequest: vi.fn(async () => undefined),
+  };
+});
+
+import { getDepositBtcAddress } from './getDepositBtcAddress';
+import { ChainId } from '../../common/chains';
+import { Env } from '@lombard.finance/sdk-common';
+import { getChainNameById } from '../../common/blockchain-identifier';
+import { Token, TOKEN_ADDRESSES } from '../../tokens/token-addresses';
+import { DAY, now, toUnix } from '../../utils/time';
+import { makeRequest } from './make-request';
+import { IDepositAddress, IGetDepositBtcAddressesParameters } from './types';
+
+const ACCOUNT_ADDRESS_A = '0x1111111111111111111111111111111111111111';
+
+const DEPOSIT_ADDRESS_A = 'bc1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+const DEPOSIT_ADDRESS_B = 'bc1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
+const DEPOSIT_ADDRESS_C = 'bc1ccccccccccccccccccccccccccccccccccccccc';
+
+const makeDepositAddress = (
+  depositAddress: string,
+  chainId: ChainId,
+  toAddress: string,
+  createdAt: number,
+  token?: Token,
+) =>
+  ({
+    btc_address: depositAddress,
+    type: 'ADDRESS_TYPE_DEPOSIT',
+    deposit_metadata: {
+      to_address: toAddress,
+      to_blockchain: getChainNameById(chainId),
+      referral: 'lombard',
+      ...(token != null
+        ? {
+            token_address: TOKEN_ADDRESSES[token]?.[Env.prod]?.[chainId],
+            aux_version: 1,
+          }
+        : {}),
+    },
+    created_at: createdAt.toString(),
+  }) as IDepositAddress;
+
+describe('getDepositBtcAddress', () => {
+  it.each([
+    [
+      'Wants LBTC on Ethereum, should return the most recent LBTC address',
+      [
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_A,
+          ChainId.ethereum,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+          Token.LBTC,
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_B,
+          ChainId.ethereum,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 1),
+          Token.LBTC,
+        ),
+      ],
+      Token.LBTC,
+      ChainId.ethereum,
+      DEPOSIT_ADDRESS_B,
+    ],
+
+    [
+      'Wants LBTC on Ethereum, no token information in the API response, should return the most recent LBTC address',
+      [
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_A,
+          ChainId.ethereum,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_B,
+          ChainId.ethereum,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 1),
+        ),
+      ],
+      Token.LBTC,
+      ChainId.ethereum,
+      DEPOSIT_ADDRESS_B,
+    ],
+
+    [
+      'Wants LBTC on Katana, only NativeLBTC address, should throw an error',
+      [
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_A,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+          Token.NativeLBTC,
+        ),
+      ],
+      Token.LBTC,
+      ChainId.katana,
+      undefined,
+    ],
+
+    [
+      'Wants NativeLBTC on Katana, should return the most recent NativeLBTC address',
+      [
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_A,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 1),
+          Token.LBTC,
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_B,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+          Token.LBTC,
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_C,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+          Token.NativeLBTC,
+        ),
+      ],
+      Token.NativeLBTC,
+      ChainId.katana,
+      DEPOSIT_ADDRESS_C,
+    ],
+
+    [
+      'Wants BTCK (alias of NativeLBTC) on Katana, should return the most recent NativeLBTC address',
+      [
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_A,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+          Token.NativeLBTC,
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_B,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 0),
+          Token.LBTC,
+        ),
+      ],
+      Token.BTCK,
+      ChainId.katana,
+      DEPOSIT_ADDRESS_A,
+    ],
+
+    [
+      'Wants NativeLBTC on Katana, no token information in the API response, should throw an error',
+      [
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_A,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_B,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 0),
+        ),
+      ],
+      Token.BTCK,
+      ChainId.katana,
+      undefined,
+    ],
+
+    [
+      'Wants LBTC on Ethereum, should return the most recent LBTC address (legacy call)',
+      [
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_A,
+          ChainId.ethereum,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_B,
+          ChainId.katana,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 0),
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_C,
+          ChainId.base,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 0),
+          Token.LBTC,
+        ),
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_C,
+          ChainId.base,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 0),
+          Token.NativeLBTC,
+        ),
+      ],
+      undefined,
+      ChainId.ethereum,
+      DEPOSIT_ADDRESS_A,
+    ],
+
+    [
+      'Wants NativeLBTC on Ethereum, no token address for NativeLBTC on Ethereum, should throw an error.',
+      [
+        makeDepositAddress(
+          DEPOSIT_ADDRESS_A,
+          ChainId.ethereum,
+          ACCOUNT_ADDRESS_A,
+          toUnix(now() - DAY * 2),
+        ),
+      ],
+      Token.NativeLBTC,
+      ChainId.ethereum,
+      undefined,
+    ],
+  ])(
+    '$0',
+    async (
+      _description: string,
+      API_RESPONSE: IDepositAddress[],
+      token: Token | undefined,
+      chainId: ChainId,
+      expectedAddress: string | undefined,
+    ) => {
+      const params: IGetDepositBtcAddressesParameters = {
+        address: ACCOUNT_ADDRESS_A,
+        chainId,
+        env: Env.prod,
+        partnerId: 'lombard',
+      };
+
+      (makeRequest as Mock).mockImplementation(async () => API_RESPONSE);
+
+      if (!expectedAddress) {
+        await expect(
+          getDepositBtcAddress({ ...params, token }),
+        ).rejects.toThrow();
+      } else {
+        const address = await getDepositBtcAddress({
+          ...params,
+          token,
+        });
+
+        expect(address).toBe(expectedAddress);
+      }
+    },
+  );
+});

package/src/api-functions/getDepositBtcAddress/getDepositBtcAddress.ts

@@ -1,168 +1,20 @@
-import axios from 'axios';
-import { getApiConfig } from '../../common/api-config';
+import { isSolanaChain, isSuiChain, isValidChain } from '../../common/chains';
 import {
-  BlockchainIdentifier,
-  getChainNameById,
-} from '../../common/blockchain-identifier';
-import {
-  ChainId,
-  isValidChain,
-  SolanaChain,
-  SuiChain,
-} from '../../common/chains';
-import { IEnvParam } from '../../common/parameters';
-import { Token } from '../../tokens/token-addresses';
+  getSolanaTokenAddress,
+  getSuiTokenAddress,
+  Token,
+} from '../../tokens/token-addresses';
 import { getTokenContractInfo } from '../../tokens/tokens';
-
-export interface IDepositAddress {
-  /**
-   * The deposit address for BTC.
-   */
-  btc_address: string;
-  /**
-   * The address creation timestamp.
-   */
-  created_at: string;
-  /**
-   * A flag determining whether an address is deprecated (no longer valid for depositing BTC).
-   */
-  deprecated?: boolean;
-  /**
-   * Type of an address.
-   * @constant {string} - ADDRESS_TYPE_DEPOSIT
-   */
-  type: string;
-  /**
-   * A flag determining whether an address has been used.
-   */
-  used?: boolean;
-
-  /**
-   * The deposit address metadata
-   */
-  deposit_metadata: {
-    /**
-     * The partner (referral) id.
-     */
-    referral: string;
-    /**
-     * The partner (referral) id.
-     */
-    partner_id: string;
-    /**
-     * The destination address.
-     */
-    to_address: string;
-    /**
-     * The destination blockchain corresponding to the `to_address`
-     */
-    to_blockchain: BlockchainIdentifier;
-    /**
-     * The destination token address
-     */
-    token_address?: string;
-    /**
-     * The aux version (paired with the token_address)
-     */
-    aux_version?: number;
-  };
-}
-
-interface IDepositAddressesResponse {
-  addresses: IDepositAddress[];
-  has_more?: boolean;
-}
-
-interface IApiError {
-  code: number;
-  message?: string;
-}
-
-export interface IGetDepositBtcAddressesParameters extends IEnvParam {
-  /**
-   * The destination address where LBTC will be claimed.
-   */
-  address: string;
-  /**
-   * The destination chain where the `address` exists and where LBTC will be claimed.
-   */
-  chainId: ChainId | SuiChain | SolanaChain;
-  /**
-   * The maximum number of items to return.
-   * @default {number} 1
-   */
-  limit?: number;
-
-  /**
-   * The number of items to skip before starting to return the items.
-   * @default {number} 0
-   */
-  offset?: number;
-
-  /**
-   * The partner (referral) id.
-   * @default {string} "lombard"
-   */
-  partnerId?: string;
-}
-
-async function makeRequest({
-  address,
-  chainId,
-  env,
-  limit,
-  offset,
-  partnerId,
-}: IGetDepositBtcAddressesParameters) {
-  const { baseApiUrl } = getApiConfig(env);
-
-  // throws an error if `chainId` is unknown
-  const destinationBlockchain = getChainNameById(chainId);
-
-  const params = {
-    asc: false,
-    limit,
-    offset,
-    referralId: partnerId || 'lombard',
-  };
-
-  // remove undefined fields, undefined limit and offset params cause error
-  for (const [k, v] of Object.entries(params)) {
-    if (v === undefined) {
-      delete params[k as keyof typeof params];
-    }
-  }
-
-  const url = `api/v1/address/destination/${destinationBlockchain}/${address}`;
-  try {
-    const { data } = await axios.get<IDepositAddressesResponse>(url, {
-      baseURL: baseApiUrl,
-      params,
-    });
-
-    return data.addresses || [];
-  } catch (err) {
-    if (axios.isAxiosError<IApiError>(err)) {
-      const message = err.response?.data.message;
-      throw new Error(message);
-    }
-  }
-}
-
-export type IGetDepositBtcAddressParameters = { token?: Token } & Pick<
+import type {
   IGetDepositBtcAddressesParameters,
-  'address' | 'chainId' | 'env' | 'partnerId'
->;
+  IGetDepositBtcAddressParameters,
+} from './types';
+import { makeRequest } from './make-request';
+import { getChainNameById } from '../../common/blockchain-identifier';
 
 /**
  * Returns the current address for depositing BTC by given parameters.
  *
- * @param {IGetDepositBtcAddressParameters} parameters - The parameters.
- * @param {string} parameters.address - The account address.
- * @param {ChainId} parameters.chainId - The chain id.
- * @param {Env} parameters.env - The optional environment identifier.
- * @param {string} parameters.partnerId - The partner (referral) id.
- *
  * @throws {Error} - Throws an error if no address found or the provided chain id is not supported.
  */
 export async function getDepositBtcAddress({
@@ -192,41 +44,65 @@ export async function getDepositBtcAddress({
   try {
     if (isValidChain(chainId)) {
       const tokenContractInfo = await getTokenContractInfo(token, chainId, env);
-
       tokenAddressFilter = {
         token_address: tokenContractInfo.address.toLowerCase(),
-        aux_version: token === Token.BTCK ? 1 : undefined,
       };
     }
+
+    if (isSuiChain(chainId)) {
+      const tokenAddress = getSuiTokenAddress(chainId, env);
+      if (tokenAddress) {
+        tokenAddressFilter = {
+          token_address: tokenAddress.toLowerCase(),
+        };
+      }
+    }
+
+    if (isSolanaChain(chainId)) {
+      const tokenAddress = getSolanaTokenAddress(chainId, env);
+      if (tokenAddress) {
+        tokenAddressFilter = {
+          token_address: tokenAddress.toLowerCase(),
+        };
+      }
+    }
   } catch {
     // NOOP
   }
 
-  const addresses = (_addresses || []).filter(a => {
-    if (!tokenAddressFilter) {
-      // Get only the non token specific deposit addresses.
-      return !a.deposit_metadata.token_address;
-    }
+  const addresses = (_addresses || [])
+    .filter(
+      a =>
+        // filter by chain id
+        a.deposit_metadata.to_blockchain.toLowerCase() ===
+          getChainNameById(chainId).toLowerCase() &&
+        // filter by address
+        a.deposit_metadata.to_address.toLowerCase() === address.toLowerCase(),
+    )
+    .filter(a => {
+      if (!tokenAddressFilter) {
+        return false;
+      }
 
-    // check if token addresses are matched
-    let isForToken =
-      a.deposit_metadata.token_address?.toLowerCase() ===
-      tokenAddressFilter.token_address;
-    // check if aux version is matched (if provided)
-    if (tokenAddressFilter.aux_version != null) {
-      isForToken =
-        isForToken &&
-        a.deposit_metadata.aux_version === tokenAddressFilter.aux_version;
-    }
+      // check if token addresses are matched
+      let isForToken =
+        a.deposit_metadata.token_address?.toLowerCase() ===
+        tokenAddressFilter.token_address;
+      // check if aux version is matched (if provided)
+      if (tokenAddressFilter.aux_version != null) {
+        isForToken =
+          isForToken &&
+          a.deposit_metadata.aux_version === tokenAddressFilter.aux_version;
+      }
 
-    // token_address can also be empty (null) when the address is for LBTC.
-    if (token === Token.LBTC) {
-      isForToken = isForToken || !a.deposit_metadata.token_address;
-    }
+      // token_address can also be empty (null) when the address is for LBTC.
+      if (token === Token.LBTC) {
+        isForToken = isForToken || !a.deposit_metadata.token_address;
+      }
 
-    // Get only the addresses for the specified token.
-    return isForToken;
-  });
+      // Get only the addresses for the specified token.
+      return isForToken;
+    });
 
   if (addresses && addresses.length > 0) {
     const mostRecentAddress = addresses.reduce((mostRecent, cur) => {

package/src/api-functions/getDepositBtcAddress/getDepositBtcAddresses.stories.tsx

@@ -7,10 +7,8 @@ import { CodeBlock } from '../../stories/components/CodeBlock';
 import { functionType } from '../../stories/components/decorators';
 import { EXAMPLE_EVM_ADDRESS } from '../../stories/constants';
 import useQuery from '../../stories/hooks/useQuery';
-import {
-  IGetDepositBtcAddressesParameters,
-  getDepositBtcAddresses,
-} from './getDepositBtcAddress';
+import { getDepositBtcAddresses } from './getDepositBtcAddress';
+import { IGetDepositBtcAddressesParameters } from './types';
 
 const meta = {
   title: 'api/getDepositBtcAddresses',

package/src/api-functions/getDepositBtcAddress/make-request.ts

@@ -0,0 +1,51 @@
+import axios from 'axios';
+import { getApiConfig } from '../../common/api-config';
+import { getChainNameById } from '../../common/blockchain-identifier';
+import {
+  IApiError,
+  IDepositAddressesResponse,
+  IGetDepositBtcAddressesParameters,
+} from './types';
+
+export async function makeRequest({
+  address,
+  chainId,
+  env,
+  limit,
+  offset,
+  partnerId,
+}: IGetDepositBtcAddressesParameters) {
+  const { baseApiUrl } = getApiConfig(env);
+
+  // throws an error if `chainId` is unknown
+  const destinationBlockchain = getChainNameById(chainId);
+
+  const params = {
+    asc: false,
+    limit,
+    offset,
+    referralId: partnerId || 'lombard',
+  };
+
+  // remove undefined fields, undefined limit and offset params cause error
+  for (const [k, v] of Object.entries(params)) {
+    if (v === undefined) {
+      delete params[k as keyof typeof params];
+    }
+  }
+
+  const url = `api/v1/address/destination/${destinationBlockchain}/${address}`;
+  try {
+    const { data } = await axios.get<IDepositAddressesResponse>(url, {
+      baseURL: baseApiUrl,
+      params,
+    });
+
+    return data.addresses || [];
+  } catch (err) {
+    if (axios.isAxiosError<IApiError>(err)) {
+      const message = err.response?.data.message;
+      throw new Error(message);
+    }
+  }
+}