@lombard.finance/sdk 2.5.2 → 3.2.0

package/src/contract-functions/signStakeAndBake/signStakeAndBake.ts

@@ -0,0 +1,145 @@
+import { makeWalletClient } from '../../clients/wallet-client';
+import { CommonWriteParameters } from '../../common/parameters';
+import {
+  isVedaVaultStakeAndBakeChain,
+  Vault,
+  VAULTS,
+} from '../../vaults/lib/config';
+import { getPermitNonce } from '../getPermitNonce/getPermitNonce';
+import BigNumber from 'bignumber.js';
+import { DAY, now, toUnix } from '../../utils/time';
+import { getTokenContractInfo } from '../../tokens/tokens';
+import { Token } from '../../tokens/token-addresses';
+
+export interface ISignStakeAndBakeParams extends CommonWriteParameters {
+  /**
+   * The approved value that will be automatically claimed and deposited
+   * to the chosen vault.
+   */
+  value: BigNumber.Value;
+  /**
+   * The expiration UNIX time of the signature.
+   * Defaults to 24 hours from the time of signing.
+   */
+  expiry?: number;
+  /**
+   * The chosen DeFi vault to which the funds will be deposited.
+   */
+  vaultKey?: Vault;
+}
+
+export interface ISignStakeAndBakeResult {
+  /**
+   * The signature.
+   */
+  signature: string;
+  /**
+   * The typed data used to generate the signature.
+   */
+  typedData: string;
+}
+
+/**
+ * Signs the "stake and bake" signature that allows Lombard to claim specified
+ * amount of BTC (LBTC) and deposit that amount directly to the specified DeFi
+ * vault.
+ *
+ * In order for the "stake and bake" process to work a user has to store the
+ * signature to the Lombard's system, see: `storeStakeAndBakeSignature`
+ *
+ * @param {ISignStakeAndBakeParams} parameters - The parameters.
+ * @param {BigNumber.Value} parameters.value - The amount of BTC that's going to be claimed and deposited to the DeFi vault.
+ * @param {number} parameters.expiry = The optional expiration UNIX time of the signature.
+ * @param {Vault} parameters.vaultKey - The optional DeFi vault identifier.
+ * @param {Address} parameters.account - The EVM account address.
+ * @param {ChainId} parameters.chainId - The chain id.
+ * @param {EIP1193Provider} parameters.provider - The EIP1193 provider.
+ * @param {string} parameters.rpcUrl - The optional rpc url.
+ *
+ * @returns {Promise<ISignStakeAndBakeResult>} - The signature and typed data.
+ */
+export async function signStakeAndBake({
+  account,
+  expiry = toUnix(now() + DAY),
+  value,
+  vaultKey = Vault.Veda,
+  chainId,
+  provider,
+  rpcUrl,
+  env,
+}: ISignStakeAndBakeParams): Promise<ISignStakeAndBakeResult> {
+  const vault = VAULTS[vaultKey];
+  if (!vault) {
+    throw new Error(`Unknown vault key: ${vaultKey}`);
+  }
+
+  if (!isVedaVaultStakeAndBakeChain(chainId)) {
+    throw new Error(
+      `Unsupported chain id: ${chainId}. Please switch to one of the supported chains: ${vault.stakeAndBakeChains.join(', ')}`,
+    );
+  }
+
+  const lbtcContract = getTokenContractInfo(Token.LBTC, chainId, env);
+  const walletClient = makeWalletClient({ chainId, provider });
+  const spenderContract = vault.spenderContracts[chainId];
+
+  const nonce = await getPermitNonce({
+    owner: account,
+    chainId,
+    rpcUrl,
+  });
+
+  const typedData: Parameters<typeof walletClient.signTypedData>[0] = {
+    account,
+    domain: {
+      name: 'Lombard Staked Bitcoin',
+      version: '1',
+      chainId: BigInt(chainId),
+      verifyingContract: lbtcContract.address,
+    },
+    types: {
+      EIP712Domain: [
+        {
+          name: 'name',
+          type: 'string',
+        },
+        {
+          name: 'version',
+          type: 'string',
+        },
+        {
+          name: 'chainId',
+          type: 'uint256',
+        },
+        {
+          name: 'verifyingContract',
+          type: 'address',
+        },
+      ],
+      Permit: [
+        { name: 'owner', type: 'address' },
+        { name: 'spender', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+      ],
+    },
+    primaryType: 'Permit',
+    message: {
+      owner: account,
+      spender: spenderContract.address,
+      value: BigInt(BigNumber(value).toFixed()),
+      nonce: BigInt(nonce),
+      deadline: BigInt(expiry),
+    },
+  };
+
+  const signature = await walletClient.signTypedData(typedData);
+
+  return {
+    signature,
+    typedData: JSON.stringify(typedData, (_, v) =>
+      typeof v === 'bigint' ? v.toString() : v,
+    ),
+  };
+}

package/src/contract-functions/unstakeLBTC/unstakeLBTC.stories.tsx

@@ -0,0 +1,80 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { DEFAULT_ENV } from '@lombard.finance/sdk-common';
+import { Button } from '../../stories/components/Button';
+import { CodeBlock } from '../../stories/components/CodeBlock';
+import useQuery from '../../stories/hooks/useQuery';
+import { IUnstakeLBTCParams, unstakeLBTC } from './unstakeLBTC';
+import { ConnectButton } from '../../stories/components/ConnectButton';
+import {
+  canPerformAction,
+  useConnection,
+} from '../../stories/hooks/useConnection';
+import {
+  functionType,
+  wagmiDecorator,
+} from '../../stories/components/decorators';
+
+const meta = {
+  title: 'write/unstakeLBTC',
+  component: StoryView,
+  tags: ['autodocs'],
+  decorators: [wagmiDecorator, functionType('write')],
+} satisfies Meta<typeof StoryView>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const WithParams: Story = {
+  args: {
+    amount: 0.00001,
+    btcAddress: '',
+    env: DEFAULT_ENV,
+  },
+};
+
+type ClaimLBTCProps = Pick<IUnstakeLBTCParams, 'btcAddress' | 'env' | 'amount'>;
+
+export function StoryView(props: ClaimLBTCProps) {
+  const connection = useConnection();
+
+  const request = async () => {
+    if (!canPerformAction(connection)) {
+      alert('Not connected');
+      return;
+    }
+
+    return unstakeLBTC({
+      amount: props.amount,
+      btcAddress: props.btcAddress,
+
+      account: connection.account.address,
+      chainId: connection.account.chainId,
+      provider: connection.provider,
+    });
+  };
+
+  const { data, error, isLoading, refetch } = useQuery(request, [], false);
+
+  return (
+    <>
+      <p>
+        This function unstakes the specified amount of LBTC and transfers the
+        equivalent amount of BTC to the provided BTC address.
+      </p>
+
+      <div className="mb-4">
+        <ConnectButton />
+      </div>
+
+      <Button
+        onClick={refetch}
+        disabled={isLoading || !connection.account.address}
+        isLoading={isLoading}
+        actionName={unstakeLBTC.name}
+      />
+
+      <CodeBlock text={error || data} />
+    </>
+  );
+}

package/src/contract-functions/unstakeLBTC/unstakeLBTC.ts

@@ -0,0 +1,66 @@
+import { getOutputScript } from '@lombard.finance/sdk-common';
+import { CommonWriteParameters } from '../../common/parameters';
+import { toSatoshi } from '../../utils/satoshi';
+import { makeWalletClient } from '../../clients/wallet-client';
+import { makePublicClient } from '../../clients/public-client';
+import { CHAIN_ID_TO_VIEM_CHAIN_MAP } from '../../common/chains';
+import { Hex } from 'viem';
+import BigNumber from 'bignumber.js';
+import { getTokenContractInfo } from '../../tokens/tokens';
+import { Token } from '../../tokens/token-addresses';
+
+/**
+ * The unstake parameters.
+ */
+export interface IUnstakeLBTCParams extends CommonWriteParameters {
+  /**
+   * The BTC address to send the unstaked BTC to.
+   */
+  btcAddress: string;
+  /**
+   * The amount of LBTC to unstake.
+   */
+  amount: BigNumber.Value;
+}
+
+/**
+ * Unstakes (redeems) specified amount of LBTC and sends the equivalent amount
+ * of BTC to the provided BTC address.
+ * @param {IUnstakeLBTCParams} parameters - The unstake parameters.
+ * @param {string} parameters.btcAddress - The BTC address.
+ * @param {BigNumber.Value} parameters.amount - The amount of LBTC to unstake.
+ * @param {Address} parameters.account - The EVM address.
+ * @param {ChainId} parameters.chainId - The chain id.
+ * @param {EIP1193Provider} parameters.provider - The EIP1193 provider.
+ * @param {string} parameters.rpcUrl - The optional rpc url.
+ */
+export async function unstakeLBTC({
+  btcAddress,
+  amount,
+  account,
+  chainId,
+  provider,
+  rpcUrl,
+  env,
+}: IUnstakeLBTCParams): Promise<Hex> {
+  const outputScript = getOutputScript(btcAddress, env);
+  const amountSat = toSatoshi(amount).toNumber();
+
+  const lbtcContract = getTokenContractInfo(Token.LBTC, chainId, env);
+
+  const publicClient = makePublicClient({ chainId, rpcUrl });
+  const walletClient = makeWalletClient({ provider, chainId });
+
+  const { request } = await publicClient.simulateContract({
+    address: lbtcContract.address,
+    account,
+    chain: CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId],
+    abi: lbtcContract.abi,
+    functionName: 'redeem',
+    args: [outputScript, BigInt(amountSat)],
+  });
+
+  const txHash = await walletClient.writeContract(request);
+
+  return txHash;
+}

package/src/index.ts

@@ -1,23 +1,46 @@
-export * from "./sdk";
-export * from "./web3Sdk";
+// API functions:
+export * from './api-functions';
 
-export * from "./common/types/types";
-export * from "./common/utils/convertSatoshi";
-export * from "./common/utils/isValidChain";
-export type { Env as TEnv } from "@lombard.finance/sdk-common";
-export { Env as OEnv } from "@lombard.finance/sdk-common";
+// READ and WRITE functions:
+export * from './contract-functions';
 
-export {
-  getVaultDeposits,
-  type GetVaultDepositsParameters,
-} from "./vaults/lib/get-vault-deposits";
+// Vault:
+export * from './vaults';
+
+// Rewards:
+export * from './rewards';
 
+// Utils:
+export * from './common/api-config';
+export * from './common/blockchain-identifier';
+export * from './common/chains';
+export {
+  SOLANA_DEVNET_CHAIN,
+  SOLANA_MAINNET_CHAIN,
+  SOLANA_TESTNET_CHAIN,
+} from './common/chains';
 export {
-  getVaultWithdrawals,
-  type GetVaultWithdrawalsParameters,
-} from "./vaults/lib/get-vault-withdrawals";
+  SUI_DEVNET_CHAIN,
+  SUI_MAINNET_CHAIN,
+  SUI_TESTNET_CHAIN,
+} from './common/chains';
+export * from './tokens/lbtc-addresses';
+export * from './utils/satoshi';
+
+// Metrics:
+export { getLBTCStats } from './metrics/get-lbtc-stats';
+
+// Re-exports:
+export type { Address, EIP1193Provider } from 'viem';
+export { Env } from '@lombard.finance/sdk-common';
 
+// Bridge:
 export {
-  getVaultPoints,
-  type GetVaultPointsParameters,
-} from "./vaults/lib/get-vault-points";
+  getBridgeInfo,
+  bridge,
+  bridgeCCIP,
+  bridgeOFT,
+  type BridgeParameters,
+  type BridgeCCIPParameters,
+  type BridgeOFTParameters,
+} from './bridge';

package/src/metrics/get-lbtc-stats.stories.tsx

@@ -0,0 +1,51 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { Button } from '../stories/components/Button';
+import { CodeBlock } from '../stories/components/CodeBlock';
+import useQuery from '../stories/hooks/useQuery';
+import { functionType, wagmiDecorator } from '../stories/components/decorators';
+import { ErrorBlock } from '../stories/components/error-block';
+import { getLBTCStats } from './get-lbtc-stats';
+
+const meta = {
+  title: 'metrics/getLBTCStats',
+  component: StoryView,
+  tags: ['autodocs'],
+  decorators: [wagmiDecorator, functionType('api-get')],
+} satisfies Meta<typeof StoryView>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const WithParams: Story = {
+  args: {},
+};
+
+type SignNetworkFeeProps = Parameters<typeof getLBTCStats>[0];
+
+export function StoryView(props: SignNetworkFeeProps) {
+  const request = async () => {
+    return getLBTCStats({
+      ...props,
+    });
+  };
+
+  const { data, error, isLoading, refetch } = useQuery(request, [], false);
+
+  return (
+    <>
+      <p>This function returns the total supply of the LBTC.</p>
+
+      <Button
+        onClick={refetch}
+        disabled={isLoading}
+        isLoading={isLoading}
+        actionName={getLBTCStats.name}
+      />
+
+      <ErrorBlock>{error}</ErrorBlock>
+
+      <CodeBlock text={data} />
+    </>
+  );
+}

package/src/metrics/get-lbtc-stats.ts

@@ -0,0 +1,38 @@
+import axios from 'axios';
+import { getApiConfig } from '../common/api-config';
+import { IEnvParam } from '../common/parameters';
+import BigNumber from 'bignumber.js';
+
+/** Gets the Lombard's TVL. */
+export async function getLBTCStats(parameters?: IEnvParam) {
+  const env = parameters?.env;
+
+  const { bffApiUrl } = getApiConfig(env);
+  if (!bffApiUrl) {
+    throw new Error(
+      `Could not determine API endpoint for provided environment: ${env}`,
+    );
+  }
+
+  const { data } = await axios.get<
+    { price: number; supply: number; tvl: number }[]
+  >(`${bffApiUrl}/dune-api/query/getLBTCStats`);
+
+  const { data: holders } = await axios.get<number>(
+    `${bffApiUrl}/dune-api/query/lbtc-holders`,
+  );
+
+  const { data: historicalHolders } = await axios.get<number>(
+    `${bffApiUrl}/dune-api/query/getTotalLBTCUsers`,
+  );
+
+  const stats = {
+    price: BigNumber(data[0].price),
+    supply: BigNumber(data[0].supply),
+    tvl: BigNumber(data[0].tvl),
+    holders: BigNumber(holders),
+    historicalHolders: BigNumber(historicalHolders),
+  };
+
+  return stats;
+}

package/src/rewards/index.ts

@@ -0,0 +1,26 @@
+export { claimReward, type ClaimRewardParameters } from './lib/claim-reward';
+
+export {
+  getRewardBalances,
+  type GetRewardBalancesParameters,
+  RewardBlockchainType,
+} from './lib/get-reward-balances';
+
+export {
+  getRewardSigningData,
+  type GetRewardSigningDataParameters,
+} from './lib/get-reward-signing-data';
+
+export {
+  getRewardWithdrawalFee,
+  type GetRewardWithdrawalFeeParameters,
+} from './lib/get-reward-withdrawal-fee';
+
+export {
+  getRewardWithdrawals,
+  type GetRewardsWithdrawalsParameters,
+  type RewardWithdrawal,
+  RewardWithdrawalStatus,
+} from './lib/get-reward-withdrawals';
+
+export { isRewardTokenSupported, RewardToken } from './lib/reward-tokens';

package/src/rewards/lib/claim-reward.stories.tsx

@@ -0,0 +1,82 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import {
+  functionType,
+  wagmiDecorator,
+} from '../../stories/components/decorators';
+import { Button } from '../../stories/components/Button';
+import { CodeBlock } from '../../stories/components/CodeBlock';
+import { ErrorBlock } from '../../stories/components/error-block';
+import useQuery from '../../stories/hooks/useQuery';
+import { RewardToken } from './reward-tokens';
+import { Env } from '@lombard.finance/sdk-common';
+import { claimReward, ClaimRewardParameters } from './claim-reward';
+import { ConnectButton } from '../../stories/components/ConnectButton';
+import {
+  canPerformAction,
+  useConnection,
+} from '../../stories/hooks/useConnection';
+import { ChainId } from '../../common/chains';
+import { EXAMPLE_BABYLON_ADDRESS } from '../../stories/constants';
+
+const meta = {
+  title: 'rewards/claimReward',
+  component: StoryView,
+  tags: ['autodocs'],
+  decorators: [wagmiDecorator, functionType('write')],
+} satisfies Meta<typeof StoryView>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const WithParams: Story = {
+  args: {
+    to: EXAMPLE_BABYLON_ADDRESS,
+    amount: '0.001',
+    rewardToken: RewardToken.BABY,
+    chainId: ChainId.ethereum,
+    env: Env.stage,
+  },
+};
+
+type Props = Omit<ClaimRewardParameters, 'account' | 'provider'>;
+
+export function StoryView(props: Props) {
+  const connection = useConnection();
+
+  const request = async () => {
+    if (!canPerformAction(connection)) {
+      alert('Please connect');
+      return;
+    }
+
+    return claimReward({
+      account: connection.account.address,
+      provider: connection.provider,
+      ...props,
+    });
+  };
+
+  const { data, error, isLoading, refetch } = useQuery(request, [], false);
+
+  return (
+    <>
+      <p>This function claims a reward earned by a user.</p>
+
+      <div className="mb-4">
+        <ConnectButton />
+      </div>
+
+      <Button
+        onClick={refetch}
+        disabled={isLoading || !canPerformAction(connection)}
+        isLoading={isLoading}
+        actionName={claimReward.name}
+      />
+
+      <ErrorBlock>{error}</ErrorBlock>
+
+      <CodeBlock text={data} />
+    </>
+  );
+}

package/src/rewards/lib/claim-reward.ts

@@ -0,0 +1,84 @@
+import BigNumber from 'bignumber.js';
+import { CommonWriteParameters } from '../../common/parameters';
+import axios from 'axios';
+import { getApiConfig } from '../../common/api-config';
+import { makeWalletClient } from '../../clients/wallet-client';
+import { getRewardWithdrawalFee } from './get-reward-withdrawal-fee';
+import { getRewardSigningData } from './get-reward-signing-data';
+import {
+  mapDataToRewardWithdrawal,
+  WithdrawalData,
+} from './get-reward-withdrawals';
+import { isRewardTokenSupported, RewardToken } from './reward-tokens';
+
+type Response = {
+  withdrawal: WithdrawalData;
+};
+
+export type ClaimRewardParameters = {
+  /** The reward token. */
+  rewardToken: RewardToken;
+  /** The amount of reward to be withdrawn (claimed). */
+  amount: BigNumber.Value;
+  /** The destination address. */
+  to: string;
+} & CommonWriteParameters;
+
+const REQUEST_WITHDRAW_URL =
+  '/api/v1/distribution/account/{from}/withdrawals/{to}';
+
+/** Claims a reward. */
+export async function claimReward({
+  account: from,
+  rewardToken,
+  amount,
+  to,
+  chainId,
+  provider,
+  env,
+}: ClaimRewardParameters) {
+  if (!isRewardTokenSupported(rewardToken)) {
+    throw new Error(`Unknown reward token: ${RewardToken}`);
+  }
+
+  const walletClient = makeWalletClient({
+    chainId,
+    provider,
+  });
+
+  const withdrawalFee = await getRewardWithdrawalFee({
+    address: from,
+    rewardToken,
+    env,
+  });
+  const signingData = await getRewardSigningData({
+    from,
+    to,
+    amount,
+    fee: withdrawalFee,
+    rewardToken,
+    env,
+  });
+
+  const signature = await walletClient.signMessage({
+    account: from,
+    message: signingData,
+  });
+
+  const payload = {
+    amount: BigNumber(amount).toFixed(),
+    fee: BigNumber(withdrawalFee).toFixed(),
+    signature,
+  };
+
+  const { baseApiUrl } = getApiConfig(env);
+  const { data: withdrawData } = await axios.post<Response>(
+    REQUEST_WITHDRAW_URL.replace('{from}', from).replace('{to}', to),
+    payload,
+    {
+      baseURL: baseApiUrl,
+    },
+  );
+
+  return mapDataToRewardWithdrawal(withdrawData.withdrawal);
+}