@lombard.finance/sdk 2.5.2 → 3.1.0

package/src/{web3Sdk → contract-functions}/getStakeAndBakeFee/getStakeAndBakeFee.stories.tsx

@@ -1,6 +1,6 @@
 import type { Meta, StoryObj } from '@storybook/react';
 
-import { OChainId } from '../../common/types/types';
+import { ChainId } from '../../common/chains';
 import { Button } from '../../stories/components/Button';
 import { CodeBlock } from '../../stories/components/CodeBlock';
 import useQuery from '../../stories/hooks/useQuery';
@@ -8,13 +8,14 @@ import {
   getStakeAndBakeFee,
   IGetStakeAndBakeFeeParams,
 } from './getStakeAndBakeFee';
-import BigNumber from 'bignumber.js';
-import { fromSatoshi } from '../../common/utils/convertSatoshi';
+import { Vault } from '../../vaults';
+import { functionType } from '../../stories/components/decorators';
 
 const meta = {
-  title: 'Web3SDK/getStakeAndBakeFee',
+  title: 'read/getStakeAndBakeFee',
   component: StoryView,
   tags: ['autodocs'],
+  decorators: [functionType('read')],
 } satisfies Meta<typeof StoryView>;
 
 export default meta;
@@ -23,16 +24,12 @@ type Story = StoryObj<typeof meta>;
 
 export const WithParams: Story = {
   args: {
-    chainId: OChainId.binanceSmartChain,
-    rpcUrl: 'https://rpc.ankr.com/bsc',
-    vaultAddress: '0xC8bbF6153D7Ba105f1399D992ebd32B0541996ef',
+    vaultKey: Vault.Veda,
+    chainId: ChainId.ethereum,
   },
 };
 
-type GetStakeAndBakeFeeProps = Pick<
-  IGetStakeAndBakeFeeParams,
-  'chainId' | 'rpcUrl' | 'vaultAddress'
->;
+type GetStakeAndBakeFeeProps = IGetStakeAndBakeFeeParams;
 
 export function StoryView(props: GetStakeAndBakeFeeProps) {
   const request = async () => {
@@ -43,20 +40,23 @@ export function StoryView(props: GetStakeAndBakeFeeProps) {
 
   const { data, error, isLoading, refetch } = useQuery(request, [], false);
 
-  const value = new BigNumber(fromSatoshi(data || 0)).toString();
+  const value = data?.toFixed();
 
   return (
     <div>
-      <Button onClick={refetch} disabled={isLoading} isLoading={isLoading}>
-        Get Stake and Bake Fee
-      </Button>
+      <Button
+        onClick={refetch}
+        disabled={isLoading}
+        isLoading={isLoading}
+        actionName={getStakeAndBakeFee.name}
+      />
 
       <CodeBlock text={error || data?.toString()} />
 
       {data && (
         <div className="mt-4 p-4 border rounded">
           <h3 className="text-lg font-bold mb-2">Fee Details</h3>
-          <p>Stake and Bak Fee: {value} LBTC</p>
+          <p>Stake and Bake Fee: {value} LBTC</p>
         </div>
       )}
     </div>

package/src/contract-functions/getStakeAndBakeFee/getStakeAndBakeFee.tsx

@@ -0,0 +1,61 @@
+import { getErrorMessage } from '../../utils/err';
+import { CommonParameters } from '../../common/parameters';
+import { isVedaVaultStakeAndBakeChain, Vault, VAULTS } from '../../vaults';
+import { makePublicClient } from '../../clients/public-client';
+import { getContract } from 'viem';
+import { fromSatoshi } from '../../utils/satoshi';
+import BigNumber from 'bignumber.js';
+
+export interface IGetStakeAndBakeFeeParams
+  extends Omit<CommonParameters, 'env'> {
+  /**
+   * The DeFi vault identifier.
+   */
+  vaultKey?: Vault;
+}
+
+/**
+ * Get Stake and bake fee.
+ *
+ * @param {IGetStakeAndBakeFeeParams} parameters - The parameters.
+ * @param {Vault} parameters.vaultKey - The optional DeFi vault identifier.
+ * @param {ChainId} parameters.chainId - The chain id.
+ * @param {string} parameters.rpcUrl - The optional rpc url.
+ *
+ * @returns Stake and bake fee amount.
+ */
+export async function getStakeAndBakeFee({
+  vaultKey = Vault.Veda,
+  chainId,
+  rpcUrl,
+}: IGetStakeAndBakeFeeParams): Promise<BigNumber> {
+  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 spender = vault.spenderContracts[chainId];
+  if (!spender) {
+    throw new Error('Could not retrieve the stake and bake contract.');
+  }
+
+  try {
+    const client = makePublicClient({ chainId, rpcUrl });
+    const spenderContract = getContract({
+      abi: spender.abi,
+      address: spender.address,
+      client,
+    });
+    const fee = await spenderContract.read.getStakeAndBakeFee();
+    return fromSatoshi(String(fee));
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    throw new Error(errorMessage);
+  }
+}

package/src/{web3Sdk → contract-functions}/index.ts

@@ -1,17 +1,18 @@
-export * from './approveLBTC';
-export * from './claimLBTC';
+// READ functions:
 export * from './getBasculeDepositStatus';
 export * from './getLBTCMintingFee';
 export * from './getLBTCTotalSupply';
 export * from './getPermitNonce';
-export * from './lbtcAddressConfig';
+export * from './getStakeAndBakeFee';
+
+// WRITE functions:
+export * from './approveLBTC';
+export * from './claimLBTC';
 export * from './signLbtcDestionationAddr';
 export * from './signNetworkFee';
 export * from './signStakeAndBake';
-export * from './types';
 export * from './unstakeLBTC';
-export * from './getBasculeDepositStatus';
-export * from './getLBTCTotalSupply';
-export * from './getStakeAndBakeFee';
+
+// VAULT READ functions:
 export * from './getShareValue';
 export * from './getSharesByAddress';

package/src/contract-functions/signLbtcDestionationAddr/signLbtcDestinationAddr.ts

@@ -0,0 +1,32 @@
+import { CommonWriteParameters } from '../../common/parameters';
+import { makeWalletClient } from '../../clients/wallet-client';
+
+export type SignLbtcDestinationAddrParams = Omit<
+  CommonWriteParameters,
+  'env' | 'rpcUrl'
+>;
+
+/**
+ * Signs the destination address for the LBTC in active chain
+ * in the current account. Signing is necessary for the
+ * generation of the deposit address.
+ *
+ * @param {SignLbtcDestinationAddrParams} parameters - The parameters.
+ * @param {Address} parameters.account - The EVM account address.
+ * @param {ChainId} parameters.chainId - The chain id.
+ * @param {EIP1193Provider} parameters.provider - The EIP1193 provider.
+ *
+ * @returns {Promise<string>} The signature of the message.
+ */
+export async function signLbtcDestinationAddr({
+  account,
+  chainId,
+  provider,
+}: SignLbtcDestinationAddrParams): Promise<string> {
+  const walletClient = makeWalletClient({ chainId, provider });
+
+  const message = `destination chain id is ${chainId}`;
+  const signed = await walletClient.signMessage({ account, message });
+
+  return signed;
+}

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

@@ -0,0 +1,63 @@
+import type { Meta } from '@storybook/react';
+import { Button } from '../../stories/components/Button';
+import { CodeBlock } from '../../stories/components/CodeBlock';
+import {
+  canPerformAction,
+  useConnection,
+} from '../../stories/hooks/useConnection';
+import useQuery from '../../stories/hooks/useQuery';
+import { signLbtcDestinationAddr } from './signLbtcDestinationAddr';
+import { ConnectButton } from '../../stories/components/ConnectButton';
+import {
+  functionType,
+  wagmiDecorator,
+} from '../../stories/components/decorators';
+
+const meta = {
+  title: 'write/signLbtcDestionationAddr',
+  component: StoryView,
+  tags: ['autodocs'],
+  decorators: [wagmiDecorator, functionType('write')],
+} satisfies Meta<typeof StoryView>;
+
+export default meta;
+
+export function StoryView() {
+  const connection = useConnection();
+
+  const request = async () => {
+    if (!canPerformAction(connection)) {
+      return;
+    }
+
+    return signLbtcDestinationAddr({
+      account: connection.account.address,
+      chainId: connection.account.chainId,
+      provider: connection.provider,
+    });
+  };
+
+  const { data, error, isLoading, refetch } = useQuery(request, [], false);
+
+  return (
+    <>
+      <p>
+        This method is used to get the signature of the Liquid BTC destination
+        address. The signature is used for generating the deposit address.
+      </p>
+
+      <div className="mb-4">
+        <ConnectButton />
+      </div>
+
+      <Button
+        onClick={refetch}
+        disabled={isLoading || !connection.account.address}
+        isLoading={isLoading}
+        actionName={signLbtcDestinationAddr.name}
+      />
+
+      <CodeBlock text={error || data} />
+    </>
+  );
+}

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

@@ -0,0 +1,91 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { Button } from '../../stories/components/Button';
+import { CodeBlock } from '../../stories/components/CodeBlock';
+import {
+  canPerformAction,
+  useConnection,
+} from '../../stories/hooks/useConnection';
+import useQuery from '../../stories/hooks/useQuery';
+import { ISignNetworkFeeParams, signNetworkFee } from './signNetworkFee';
+import { DAY, now, toUnix } from '../../utils/time';
+import { ConnectButton } from '../../stories/components/ConnectButton';
+import {
+  functionType,
+  wagmiDecorator,
+} from '../../stories/components/decorators';
+
+const meta = {
+  title: 'write/signNetworkFee',
+  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: {
+    fee: '1100',
+    expiry: toUnix(now() + DAY),
+  },
+};
+
+type SignNetworkFeeProps = Omit<
+  ISignNetworkFeeParams,
+  'account' | 'chainId' | 'provider'
+>;
+
+export function StoryView(props: SignNetworkFeeProps) {
+  const connection = useConnection();
+
+  const request = async () => {
+    if (!canPerformAction(connection)) {
+      return;
+    }
+
+    return signNetworkFee({
+      ...props,
+
+      account: connection.account.address,
+      chainId: connection.account.chainId,
+      provider: connection.provider,
+    });
+  };
+
+  const { data, error, isLoading, refetch } = useQuery(request, [], false);
+
+  return (
+    <>
+      <p>
+        This method is used to get the signature of the Liquid BTC destination
+        address. The signature is used for auto-mint feature.
+      </p>
+
+      <div className="mb-4">
+        <ConnectButton />
+      </div>
+
+      <Button
+        onClick={refetch}
+        disabled={isLoading || !connection.account.address}
+        isLoading={isLoading}
+        actionName={signNetworkFee.name}
+      />
+
+      <div
+        style={{
+          padding: '20px 0 0',
+          fontFamily: 'monospace',
+          fontSize: '0.8em',
+        }}
+      >
+        <span style={{ fontWeight: '800' }}>24 hours from now:</span>{' '}
+        {toUnix(now() + DAY)}
+      </div>
+
+      <CodeBlock text={error || data} />
+    </>
+  );
+}

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

@@ -0,0 +1,98 @@
+import BigNumber from 'bignumber.js';
+import { makeWalletClient } from '../../clients/wallet-client';
+import { CommonWriteParameters } from '../../common/parameters';
+import { getLBTCContractInfo } from '../../tokens/lbtc-contract';
+import { DAY, now, toUnix } from '../../utils/time';
+import { Hex } from 'viem';
+
+export interface ISignNetworkFeeParams extends CommonWriteParameters {
+  /**
+   * The authorized fee amount.
+   * Recommended amount is the same as retuned from `getLBTCMintingFee`.
+   */
+  fee: BigNumber.Value;
+  /**
+   * The expiration time of the signature.
+   * Defaults to 24h from now.
+   */
+  expiry?: number;
+}
+
+export interface ISignNetworkFeeResponse {
+  /**
+   * The signature.
+   */
+  signature: Hex;
+  /**
+   * The typed data (JSON string) used for generating the returned signature.
+   */
+  typedData: string;
+}
+
+/**
+ * Signs the network fee transaction in the current account.
+ * Signing is necessary for the auto-mint.
+ *
+ * @param {ISignNetworkFeeParams} parameters - The parameters for signing network fee
+ * @param {BigNumber.Value} parameters.fee - The fee amount (in satoshis).
+ * @param {number} parameters.expiry = The optional expiration UNIX time of the signature.
+ * @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<ISignNetworkFeeResponse>} A promise that resolves to the signature and typed data
+ */
+export async function signNetworkFee({
+  fee,
+  expiry = toUnix(now() + DAY),
+  account,
+  chainId,
+  provider,
+  env,
+}: ISignNetworkFeeParams): Promise<ISignNetworkFeeResponse> {
+  const lbtcContract = getLBTCContractInfo(chainId, env);
+  const walletClient = makeWalletClient({
+    chainId,
+    provider,
+  });
+
+  type TypedData = Parameters<typeof walletClient.signTypedData>[0];
+  const typedData: TypedData = {
+    account,
+    domain: {
+      name: 'Lombard Staked Bitcoin',
+      version: '1',
+      chainId,
+      verifyingContract: lbtcContract.address,
+    },
+    message: {
+      chainId,
+      fee: BigInt(BigNumber(fee).toFixed()),
+      expiry,
+    },
+    primaryType: 'feeApproval',
+    types: {
+      EIP712Domain: [
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'verifyingContract', type: 'address' },
+      ],
+      feeApproval: [
+        { name: 'chainId', type: 'uint256' },
+        { name: 'fee', type: 'uint256' },
+        { name: 'expiry', type: 'uint256' },
+      ],
+    },
+  };
+
+  const signature = await walletClient.signTypedData(typedData);
+
+  return {
+    signature: signature,
+    typedData: JSON.stringify(typedData, (_, v) =>
+      typeof v === 'bigint' ? v.toString() : v,
+    ),
+  };
+}

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

@@ -0,0 +1 @@
+export * from './signStakeAndBake';

package/src/{web3Sdk → contract-functions}/signStakeAndBake/signStakeAndBake.stories.tsx

@@ -1,19 +1,25 @@
 import type { Meta, StoryObj } from '@storybook/react';
-
 import { Button } from '../../stories/components/Button';
 import { CodeBlock } from '../../stories/components/CodeBlock';
-import { useConnect } from '../../stories/hooks/useConnect';
+import {
+  canPerformAction,
+  useConnection,
+} from '../../stories/hooks/useConnection';
 import useQuery from '../../stories/hooks/useQuery';
-import { fromCamelCase } from '../../stories/utils/fromCamelCase';
 import { signStakeAndBake, ISignStakeAndBakeParams } from './signStakeAndBake';
+import { ConnectButton } from '../../stories/components/ConnectButton';
+import {
+  functionType,
+  wagmiDecorator,
+} from '../../stories/components/decorators';
 
 const { name } = signStakeAndBake;
-const nameWithWhitespaces = fromCamelCase(name);
 
 const meta = {
-  title: 'Web3SDK/signStakeAndBake',
+  title: 'write/signStakeAndBake',
   component: StoryView,
   tags: ['autodocs'],
+  decorators: [wagmiDecorator, functionType('write')],
 } satisfies Meta<typeof StoryView>;
 
 export default meta;
@@ -24,72 +30,53 @@ export const WithParams: Story = {
   args: {
     value: '20000',
     expiry: 3600,
-    vaultKey: 'veda',
   },
 };
 
-type SignStakeAndBakeParams = Pick<
+type SignStakeAndBakeParams = Omit<
   ISignStakeAndBakeParams,
-  'value' | 'expiry' | 'vaultKey'
+  'account' | 'chainId' | 'provider'
 >;
 
 export function StoryView(props: SignStakeAndBakeParams) {
-  const {
-    data: connectData,
-    error: connectError,
-    isLoading: isConnectLoading,
-    connect,
-  } = useConnect();
+  const connection = useConnection();
 
   const request = async () => {
-    if (!connectData || !connectData.provider) {
+    if (!canPerformAction(connection)) {
+      alert('Not connected.');
       return;
     }
 
     return signStakeAndBake({
-      provider: connectData.provider,
-      address: connectData.account,
-      chainId: connectData.chainId,
-
       value: props.value,
       expiry: props.expiry,
-      vaultKey: props.vaultKey,
+
+      account: connection.account.address,
+      chainId: connection.account.chainId,
+      provider: connection.provider,
     });
   };
 
   const { data, error, isLoading, refetch } = useQuery(request, [], false);
 
-  const formattedConnectData = connectData && {
-    account: connectData.account,
-    chainId: connectData.chainId,
-  };
-
   return (
     <>
       <p>
-        This method is used to sign a permit for stake and bake operations. The
-        signature is used to approve spending of tokens.
+        This function generates a signature that allows Lombard to claim
+        specified amount of BTC deposited to the personal account and deposit
+        that amount automatically to the DeFi vault.
       </p>
 
       <div className="mb-4">
-        <Button
-          onClick={connect}
-          disabled={isConnectLoading}
-          isLoading={isConnectLoading}
-        >
-          Connect
-        </Button>
-
-        <CodeBlock text={connectError || formattedConnectData} />
+        <ConnectButton />
       </div>
 
       <Button
         onClick={refetch}
-        disabled={isLoading || !connectData}
+        disabled={isLoading || !connection.account.address}
         isLoading={isLoading}
-      >
-        {nameWithWhitespaces}
-      </Button>
+        actionName={signStakeAndBake.name}
+      />
 
       <CodeBlock
         text={