@lombard.finance/sdk 4.0.0 → 4.1.2

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

@@ -1,81 +0,0 @@
-import { Abi } from 'viem';
-
-import { makePublicClient } from '../../clients/public-client';
-import { makeWalletClient } from '../../clients/wallet-client';
-import { ChainId } from '../../common/chains';
-import {
-  ISignStakeAndBakeParams,
-  ISignStakeAndBakeResult,
-} from './signStakeAndBake';
-import { buildTypedData, serializeTypedData } from './typed-data-builder';
-
-/**
- * Handle approve flow (on-chain transaction).
- * Checks allowance and submits approve transaction if needed.
- */
-export async function handleApproveFlow(params: {
-  account: `0x${string}`;
-  chainId: ChainId;
-  provider: ISignStakeAndBakeParams['provider'];
-  rpcUrl: ISignStakeAndBakeParams['rpcUrl'];
-  tokenAddress: `0x${string}`;
-  tokenAbi: Abi;
-  spenderAddress: `0x${string}`;
-  typedData: ReturnType<typeof buildTypedData>;
-  requiredAmount: bigint;
-}): Promise<ISignStakeAndBakeResult> {
-  const {
-    account,
-    chainId,
-    provider,
-    rpcUrl,
-    tokenAddress,
-    tokenAbi,
-    spenderAddress,
-    typedData,
-    requiredAmount,
-  } = params;
-
-  const publicClient = makePublicClient({ chainId, rpcUrl });
-  const walletClient = makeWalletClient({ chainId, provider });
-
-  // Check current allowance
-  const currentAllowance = (await publicClient.readContract({
-    address: tokenAddress,
-    abi: tokenAbi,
-    functionName: 'allowance',
-    args: [account, spenderAddress],
-  })) as bigint;
-
-  let approvalTxHash: string | undefined;
-
-  // Submit approve transaction if allowance is insufficient
-  if (currentAllowance < requiredAmount) {
-    const hash = await walletClient.writeContract({
-      address: tokenAddress,
-      abi: tokenAbi,
-      functionName: 'approve',
-      args: [spenderAddress, requiredAmount],
-      account,
-      chain: null,
-    });
-
-    // Wait for transaction confirmation
-    const receipt = await publicClient.waitForTransactionReceipt({ hash });
-
-    if (receipt.status !== 'success') {
-      throw new Error(
-        `Approve transaction failed: ${hash}. Please try again or contact support.`,
-      );
-    }
-
-    approvalTxHash = hash;
-  }
-
-  return {
-    mode: 'approve',
-    signature: '',
-    typedData: serializeTypedData(typedData),
-    approvalTxHash,
-  };
-}

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

@@ -1,28 +0,0 @@
-import { makeWalletClient } from '../../clients/wallet-client';
-import { ChainId } from '../../common/chains';
-import {
-  ISignStakeAndBakeParams,
-  ISignStakeAndBakeResult,
-} from './signStakeAndBake';
-import { buildTypedData, serializeTypedData } from './typed-data-builder';
-
-/**
- * Handle permit flow (off-chain signature).
- * Signs EIP-2612 typed data for gasless approval.
- */
-export async function handlePermitFlow(params: {
-  chainId: ChainId;
-  provider: ISignStakeAndBakeParams['provider'];
-  typedData: ReturnType<typeof buildTypedData>;
-}): Promise<ISignStakeAndBakeResult> {
-  const { chainId, provider, typedData } = params;
-
-  const walletClient = makeWalletClient({ chainId, provider });
-  const signature = await walletClient.signTypedData(typedData);
-
-  return {
-    mode: 'permit',
-    signature,
-    typedData: serializeTypedData(typedData),
-  };
-}

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

@@ -1,2 +0,0 @@
-export * from './signStakeAndBake';
-export { getStakeAndBakeConfig } from './validation';

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

@@ -1,202 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-import type { Meta, StoryObj } from '@storybook/react';
-import { useState } from 'react';
-
-import { DefiProtocol } from '../../defi/defi-registry';
-import { Button } from '../../stories/components/Button';
-import { CodeBlock } from '../../stories/components/CodeBlock';
-import { ConnectButton } from '../../stories/components/ConnectButton';
-import {
-  functionType,
-  wagmiDecorator,
-} from '../../stories/components/decorators';
-import {
-  canPerformAction,
-  useConnection,
-} from '../../stories/hooks/useConnection';
-import useQuery from '../../stories/hooks/useQuery';
-import { Token } from '../../tokens/token-addresses';
-import { ISignStakeAndBakeParams, signStakeAndBake } from './signStakeAndBake';
-
-const meta = {
-  title: 'write/signStakeAndBake',
-  component: StoryView,
-  tags: ['autodocs'],
-  decorators: [wagmiDecorator, functionType('write')],
-  argTypes: {
-    token: {
-      options: ['BTC', Token.LBTC, Token.BTCb],
-      control: { type: 'select' },
-      description:
-        'Token to stake (BTC converts to LBTC, BTCb uses approve mode)',
-    },
-    vault: {
-      options: Object.values(DefiProtocol),
-      control: { type: 'select' },
-      description: 'Vault to stake into (Veda: LBTC/BTC, Silo: BTCb)',
-    },
-    env: {
-      options: [Env.prod, Env.testnet, Env.stage, Env.dev],
-      control: { type: 'select' },
-      description: 'Environment (affects contract addresses)',
-    },
-    value: {
-      control: { type: 'text' },
-      description: 'Amount to stake (in token units)',
-    },
-  },
-} satisfies Meta<typeof StoryView>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const PermitFlow_LBTC_Ethereum: Story = {
-  name: 'Permit Flow: LBTC on Ethereum',
-  args: {
-    value: '10000',
-    token: Token.LBTC,
-    vault: DefiProtocol.Veda,
-    env: Env.prod,
-  },
-};
-
-export const PermitFlow_BTC_Ethereum: Story = {
-  name: 'Permit Flow: BTC to LBTC on Ethereum',
-  args: {
-    value: '10000',
-    token: 'BTC',
-    vault: DefiProtocol.Veda,
-    env: Env.prod,
-  },
-};
-
-export const ApproveFlow_BTCb_Fuji: Story = {
-  name: 'Approve Flow: BTCb on Avalanche Fuji',
-  args: {
-    value: '5000',
-    token: Token.BTCb,
-    vault: DefiProtocol.Silo,
-    env: Env.testnet,
-  },
-};
-
-type SignStakeAndBakeParams = Omit<
-  ISignStakeAndBakeParams,
-  'account' | 'chainId' | 'provider'
-> & {
-  vault?: DefiProtocol;
-  env?: Env;
-};
-
-export function StoryView(props: SignStakeAndBakeParams) {
-  const connection = useConnection();
-  const [showRawData, setShowRawData] = useState(false);
-
-  const request = async () => {
-    if (!canPerformAction(connection)) {
-      alert('Not connected.');
-      return;
-    }
-
-    return signStakeAndBake({
-      value: props.value,
-      expiry: props.expiry,
-      token: props.token,
-      vaultKey: props.vault || DefiProtocol.Veda,
-      account: connection.account.address,
-      chainId: connection.account.chainId,
-      provider: connection.provider,
-      env: props.env || Env.stage,
-    });
-  };
-
-  const { data, error, isLoading, refetch } = useQuery(request, [], false);
-
-  return (
-    <>
-      <p>
-        Generates a signature that allows Lombard to claim specified amount of
-        BTC and deposit the equivalent LBTC amount (calculated using current
-        ratio) automatically to the DeFi vault.
-      </p>
-
-      <p>
-        <strong>Note:</strong> Pass the original BTC amount directly. The
-        function automatically calculates the correct LBTC amount using the
-        current exchange ratio.
-      </p>
-
-      {props.token === Token.BTCb && (
-        <p className="text-danger">
-          <strong>Important:</strong> BTCb uses on-chain approve. You'll need to
-          sign a transaction and pay gas fees. Make sure you're on Avalanche
-          Fuji testnet.
-        </p>
-      )}
-
-      <div className="mb-4">
-        <ConnectButton />
-      </div>
-
-      <Button
-        onClick={refetch}
-        disabled={isLoading || !connection.account.address}
-        isLoading={isLoading}
-        actionName={signStakeAndBake.name}
-      />
-
-      {!showRawData && data && (
-        <div className="mt-4">
-          <p>
-            <strong>Mode:</strong> {data.mode}
-          </p>
-          {data.mode === 'permit' && (
-            <p>
-              <strong>Signature:</strong> <code>{data.signature}</code>
-            </p>
-          )}
-          {data.mode === 'approve' && data.approvalTxHash && (
-            <p>
-              <strong>Transaction Hash:</strong>{' '}
-              <code>{data.approvalTxHash}</code>
-            </p>
-          )}
-          <button
-            type="button"
-            className="btn btn-sm btn-outline-secondary mt-2"
-            onClick={() => {
-              setShowRawData(true);
-            }}
-          >
-            Show full response
-          </button>
-        </div>
-      )}
-
-      {showRawData && data && (
-        <>
-          <button
-            type="button"
-            className="btn btn-sm btn-outline-secondary mt-3 mb-2"
-            onClick={() => {
-              setShowRawData(false);
-            }}
-          >
-            Hide full response
-          </button>
-          <CodeBlock
-            text={{
-              mode: data.mode,
-              signature: data.signature,
-              approvalTxHash: data.approvalTxHash,
-              typedData: data.typedData ? JSON.parse(data.typedData) : '',
-            }}
-          />
-        </>
-      )}
-
-      {error && <CodeBlock text={error} />}
-    </>
-  );
-}

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

@@ -1,160 +0,0 @@
-import { DEFAULT_ENV } from '@lombard.finance/sdk-common';
-import BigNumber from 'bignumber.js';
-
-import { CommonWriteParameters } from '../../common/parameters';
-import {
-  ApprovalMode,
-  DefiProtocol,
-  StakeAndBakeToken,
-} from '../../defi/defi-registry';
-import { DAY, now, toUnix } from '../../utils/time';
-import { getPermitNonce } from '../getPermitNonce/getPermitNonce';
-import { handleApproveFlow } from './handleApprove';
-import { handlePermitFlow } from './handlePermit';
-import { buildTypedData } from './typed-data-builder';
-import {
-  calculateStakeAndBakeLBTCAmount,
-  getStakeAndBakeTokenContract,
-} from './utils';
-import { getStakeAndBakeConfig } from './validation';
-
-export interface ISignStakeAndBakeParams extends CommonWriteParameters {
-  /**
-   * The approved BTC value that will be automatically claimed and deposited
-   * to the chosen vault. The function will internally calculate the correct LBTC amount using the current ratio.
-   */
-  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?: DefiProtocol;
-  /**
-   * The token for which the signature is generated.
-   * - Defaults to **BTC**: the amount will be converted to the corresponding
-   *   **LBTC** value based on the current ratio.
-   * - If **LBTC** is chosen: no conversion is performed.
-   */
-  token?: StakeAndBakeToken;
-}
-
-export interface ISignStakeAndBakeResult {
-  /**
-   * The approval mode used for this signature.
-   * - `permit`: Off-chain signature (EIP-2612), can be used directly by backend
-   * - `approve`: On-chain approval transaction was submitted
-   */
-  mode: ApprovalMode;
-
-  /**
-   * The signature.
-   * - For permit mode: Contains the EIP-2612 signature
-   * - For approve mode: Empty string (approval was done on-chain)
-   */
-  signature: string;
-
-  /**
-   * The typed data used to generate the signature.
-   * Contains the full EIP-712 structure for both permit and approve modes.
-   */
-  typedData: string;
-
-  /**
-   * Transaction hash for approve mode (when allowance was set).
-   * Only present when mode is 'approve' and a transaction was submitted.
-   */
-  approvalTxHash?: string;
-}
-
-/**
- * Signs the "stake and bake" signature that allows Lombard to claim specified
- * amount of BTC (converted to LBTC using current ratio) 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 will be converted to LBTC using current ratio and deposited to the DeFi vault.
- * @param {number} parameters.expiry = The optional expiration UNIX time of the signature.
- * @param {DefiProtocol} 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,
-  // TODO: Rename vaultKey to protocol
-  vaultKey: protocol = DefiProtocol.Veda,
-  token = 'BTC',
-  chainId,
-  provider,
-  rpcUrl,
-  env = DEFAULT_ENV,
-}: ISignStakeAndBakeParams): Promise<ISignStakeAndBakeResult> {
-  const strategy = getStakeAndBakeConfig(protocol, token, chainId, env);
-
-  const spenderAddress = strategy.spenderContract.address;
-
-  // Calculate permit value (with conversion if needed)
-  const permitValue =
-    strategy.amountStrategy === 'btcToLbtc'
-      ? await calculateStakeAndBakeLBTCAmount(value, env)
-      : new BigNumber(value);
-
-  // Get token contract (always use Token address for permits/approves, not adapter)
-  const tokenContract = await getStakeAndBakeTokenContract(token, chainId, env);
-  const tokenAddress = tokenContract.address;
-  const tokenAbi = tokenContract.abi;
-
-  // Calculate deadline based on expiry behavior
-  const deadline =
-    strategy.approval.deadlineStrategy === 'zero' ? 0n : BigInt(expiry);
-
-  // Get nonce if required
-  const nonce =
-    strategy.approval.nonceStrategy === 'chain'
-      ? BigInt(await getPermitNonce({ owner: account, chainId, rpcUrl, env }))
-      : 0n;
-
-  // Build typed data using config
-  const typedData = buildTypedData({
-    mode: strategy.approval.mode,
-    account,
-    chainId,
-    verifyingContract: tokenAddress,
-    domainName: strategy.approval.domainName,
-    domainVersion: strategy.approval.domainVersion,
-    spender: spenderAddress,
-    value: BigInt(permitValue.toFixed(0, BigNumber.ROUND_DOWN)),
-    nonce,
-    deadline,
-  });
-
-  // Delegate to appropriate handler based on mode
-  if (strategy.approval.mode === 'approve') {
-    return handleApproveFlow({
-      account,
-      chainId,
-      provider,
-      rpcUrl,
-      tokenAddress,
-      tokenAbi,
-      spenderAddress,
-      typedData,
-      requiredAmount: BigInt(permitValue.toFixed(0, BigNumber.ROUND_DOWN)),
-    });
-  }
-
-  // Permit mode
-  return handlePermitFlow({ chainId, provider, typedData });
-}

package/src/contract-functions/signStakeAndBake/typed-data-builder.ts

@@ -1,137 +0,0 @@
-/**
- * Typed data builders for EIP-712 signatures.
- * Centralizes EIP-712 structure creation for stake and bake operations.
- */
-
-import type { Address } from 'viem';
-
-import type { ChainId } from '../../common/chains';
-import type { ApprovalMode } from '../../defi/defi-registry';
-
-/**
- * EIP-712 domain type definition.
- * Standard across all EIP-712 signatures.
- */
-export const EIP712_DOMAIN_TYPES = [
-  { name: 'name', type: 'string' },
-  { name: 'version', type: 'string' },
-  { name: 'chainId', type: 'uint256' },
-  { name: 'verifyingContract', type: 'address' },
-] as const;
-
-/**
- * EIP-712 Permit message type definition (EIP-2612).
- * Used for gasless token approvals.
- */
-export const PERMIT_MESSAGE_TYPES = [
-  { name: 'owner', type: 'address' },
-  { name: 'spender', type: 'address' },
-  { name: 'value', type: 'uint256' },
-  { name: 'nonce', type: 'uint256' },
-  { name: 'deadline', type: 'uint256' },
-] as const;
-
-/**
- * EIP-712 Approve message type definition.
- * Used for traditional on-chain approvals (same structure as Permit).
- */
-export const APPROVE_MESSAGE_TYPES = PERMIT_MESSAGE_TYPES;
-
-/**
- * Parameters for building typed data.
- */
-export interface TypedDataParams {
-  /** Approval mode (determines primary type) */
-  mode: ApprovalMode;
-  /** User's account address */
-  account: Address;
-  /** Chain ID */
-  chainId: ChainId;
-  /** Token contract address (verifying contract) */
-  verifyingContract: Address;
-  /** EIP-712 domain name */
-  domainName: string;
-  /** EIP-712 domain version */
-  domainVersion: string;
-  /** Spender contract address */
-  spender: Address;
-  /** Amount to approve/permit (in base units) */
-  value: bigint;
-  /** Nonce for replay protection */
-  nonce: bigint;
-  /** Deadline timestamp (or 0 for no deadline) */
-  deadline: bigint;
-}
-
-/**
- * Builds EIP-712 typed data structure for signatures.
- *
- * @param params - Typed data parameters
- * @returns EIP-712 typed data structure ready for signing
- *
- * @example
- * ```typescript
- * const typedData = buildTypedData({
- *   mode: 'permit',
- *   account: '0x...',
- *   chainId: 1,
- *   verifyingContract: '0x...',
- *   domainName: 'Lombard Staked Bitcoin',
- *   domainVersion: '1',
- *   spender: '0x...',
- *   value: 1000000n,
- *   nonce: 0n,
- *   deadline: 1234567890n,
- * });
- *
- * const signature = await walletClient.signTypedData(typedData);
- * ```
- */
-export function buildTypedData(params: TypedDataParams) {
-  const primaryType = params.mode === 'permit' ? 'Permit' : 'Approve';
-
-  return {
-    account: params.account,
-    domain: {
-      name: params.domainName,
-      version: params.domainVersion,
-      chainId: BigInt(params.chainId),
-      verifyingContract: params.verifyingContract,
-    },
-    types: {
-      EIP712Domain: EIP712_DOMAIN_TYPES,
-      [primaryType]:
-        params.mode === 'permit' ? PERMIT_MESSAGE_TYPES : APPROVE_MESSAGE_TYPES,
-    },
-    primaryType,
-    message: {
-      owner: params.account,
-      spender: params.spender,
-      value: params.value,
-      nonce: params.nonce,
-      deadline: params.deadline,
-    },
-  } as const;
-}
-
-/**
- * Serializes typed data to JSON string.
- * Handles BigInt serialization by converting to strings.
- *
- * @param typedData - Typed data structure from buildTypedData
- * @returns JSON string representation
- *
- * @example
- * ```typescript
- * const typedData = buildTypedData(params);
- * const json = serializeTypedData(typedData);
- * // Store or transmit JSON string
- * ```
- */
-export function serializeTypedData(
-  typedData: ReturnType<typeof buildTypedData>,
-): string {
-  return JSON.stringify(typedData, (_, v) =>
-    typeof v === 'bigint' ? v.toString() : v,
-  );
-}

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

@@ -1,61 +0,0 @@
-import { Env } from '@lombard.finance/sdk-common';
-import BigNumber from 'bignumber.js';
-
-import { getExchangeRatio } from '../../api-functions/getLBTCExchangeRate/get-exchange-ratio';
-import { StakeAndBakeToken } from '../../defi/defi-registry';
-import { AddressKind, Token } from '../../tokens/token-addresses';
-import { getTokenContractInfo } from '../../tokens/tokens';
-import { ISignStakeAndBakeParams } from './signStakeAndBake';
-
-/**
- * Calculate the permit value, applying BTC -> LBTC conversion if needed.
- */
-export const getPermitValue = async (
-  token: StakeAndBakeToken,
-  value: BigNumber.Value,
-  env: Env,
-): Promise<BigNumber> => {
-  if (!token || token === 'BTC') {
-    return await calculateStakeAndBakeLBTCAmount(value, env);
-  }
-  return new BigNumber(value);
-};
-
-/**
- * Get the token contract info for the given token.
- * For BTCb, always uses AddressKind.Token (the ERC20 token contract, not the adapter).
- */
-export const getStakeAndBakeTokenContract = async (
-  token: StakeAndBakeToken,
-  chainId: ISignStakeAndBakeParams['chainId'],
-  env: Env,
-): Promise<Awaited<ReturnType<typeof getTokenContractInfo>>> => {
-  if (!token || token === 'BTC' || token === Token.LBTC) {
-    return await getTokenContractInfo(Token.LBTC, chainId, env);
-  }
-  // For BTCb, use AddressKind.Token (ERC20 contract for permit/approve)
-  return await getTokenContractInfo(token, chainId, env, AddressKind.Token);
-};
-
-/**
- * Helper function to calculate the correct LBTC amount for stake and bake
- * based on the current BTC to LBTC ratio.
- *
- * @param btcAmount - The original BTC amount entered by the user
- * @param env - The environment for fetching the exchange ratio
- * @returns The calculated LBTC amount that should be used in the permit signature
- */
-export async function calculateStakeAndBakeLBTCAmount(
-  btcAmount: BigNumber.Value,
-  env?: Env,
-): Promise<BigNumber> {
-  try {
-    const ratios = await getExchangeRatio({ env });
-    const btcTokenRatio = ratios.LBTC?.BTCTokenRatio || new BigNumber(1);
-    const lbtcAmount = new BigNumber(btcAmount).dividedBy(btcTokenRatio);
-
-    return lbtcAmount;
-  } catch {
-    throw new Error('Failed to get exchange ratio for stake and bake');
-  }
-}