@lombard.finance/sdk 2.0.7 → 2.0.8

package/src/sdk/storeStakeAndBakeSignature/storeStakeAndBakeSignature.stories.tsx

@@ -0,0 +1,143 @@
+import { FormControl, InputLabel, MenuItem, Select } from '@mui/material';
+import type { Meta, StoryObj } from '@storybook/react';
+import { useState } from 'react';
+import { OChainId, OEnv } from '../../common/types/types';
+import { Button } from '../../stories/components/Button';
+import { CodeBlock } from '../../stories/components/CodeBlock';
+import { useConnect } from '../../stories/hooks/useConnect';
+import useQuery from '../../stories/hooks/useQuery';
+import { signStakeAndBake } from '../../web3Sdk/signStakeAndBake/signStakeAndBake';
+import {
+  IStoreStakeAndBakeSignatureParams,
+  storeStakeAndBakeSignature,
+} from './storeStakeAndBakeSignature';
+
+const EXPIRY_OPTIONS = {
+  '10 seconds': 10,
+  '1 minute': 60,
+  '1 hour': 3600,
+  '1 day': 86400,
+  '1 year': 31536000,
+} as const;
+
+type ExpiryOption = keyof typeof EXPIRY_OPTIONS;
+
+const meta = {
+  title: 'SDK/storeStakeAndBakeSignature',
+  component: StoryView,
+  tags: ['autodocs'],
+} satisfies Meta<typeof StoryView>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const WithParams: Story = {
+  args: {
+    env: OEnv.stage,
+  },
+};
+
+type StoreStakeAndBakeSignatureProps = Pick<
+  IStoreStakeAndBakeSignatureParams,
+  'env'
+>;
+
+export function StoryView(props: StoreStakeAndBakeSignatureProps) {
+  const [selectedExpiry, setSelectedExpiry] =
+    useState<ExpiryOption>('10 seconds');
+
+  const {
+    data: connectData,
+    error: connectError,
+    isLoading: isConnectLoading,
+    connect,
+  } = useConnect();
+
+  const request = async () => {
+    if (!connectData || !connectData.provider) {
+      return;
+    }
+
+    const chainId = OChainId.holesky;
+    const expiryDate =
+      Math.floor(Date.now() / 1000) + EXPIRY_OPTIONS[selectedExpiry];
+
+    const { signature, typedData } = await signStakeAndBake({
+      provider: connectData.provider,
+      address: connectData.account,
+      chainId,
+      env: props.env,
+      value: '1999',
+      expiryDate,
+    });
+
+    return storeStakeAndBakeSignature({
+      ...props,
+      signature,
+      typedData,
+    });
+  };
+
+  const { data, error, isLoading, refetch } = useQuery(
+    request,
+    [selectedExpiry],
+    false,
+  );
+
+  const formattedConnectData = connectData && {
+    account: connectData.account,
+    chainId: connectData.chainId,
+  };
+
+  return (
+    <>
+      <p>
+        This method stores the stake and bake signature in the backend. The
+        signature is used to approve spending of tokens.
+      </p>
+
+      <div className="mb-4">
+        <Button
+          onClick={connect}
+          disabled={isConnectLoading}
+          isLoading={isConnectLoading}
+        >
+          Connect
+        </Button>
+
+        <CodeBlock text={connectError || formattedConnectData} />
+      </div>
+
+      <div className="mb-4">
+        <FormControl fullWidth>
+          <InputLabel id="expiry-select-label">Expiry Time</InputLabel>
+          <Select
+            labelId="expiry-select-label"
+            value={selectedExpiry}
+            label="Expiry Time"
+            onChange={e => setSelectedExpiry(e.target.value as ExpiryOption)}
+          >
+            {Object.keys(EXPIRY_OPTIONS).map(option => (
+              <MenuItem key={option} value={option}>
+                {option}
+              </MenuItem>
+            ))}
+          </Select>
+        </FormControl>
+      </div>
+
+      <Button
+        onClick={refetch}
+        disabled={
+          isLoading || !connectData || connectData.chainId !== OChainId.holesky
+        }
+        isLoading={isLoading}
+      >
+        Store Stake and Bake Signature
+      </Button>
+
+      <CodeBlock text={error || data} />
+    </>
+  );
+}

package/src/sdk/storeStakeAndBakeSignature/storeStakeAndBakeSignature.ts

@@ -0,0 +1,56 @@
+import axios from 'axios';
+import { IEnvParam } from '../../common/types/internalTypes';
+import { getErrorMessage } from '../../common/utils/getErrorMessage';
+import { getApiConfig } from '../apiConfig';
+
+export type IStoreStakeAndBakeSignatureStatus = 'success';
+
+interface IStoreStakeAndBakeSignatureResponse {
+  status: IStoreStakeAndBakeSignatureStatus;
+}
+
+export interface IStoreStakeAndBakeSignatureParams extends IEnvParam {
+  /**
+   * signature
+   */
+  signature: string;
+  /**
+   * JSON typed data used for the signature
+   */
+  typedData: string;
+}
+
+/**
+ * Store stake and bake signature
+ *
+ * @param {IStoreStakeAndBakeSignatureParams} params - The parameters for storing stake and bake signature
+ *
+ * @returns {Promise<IStoreStakeAndBakeSignatureStatus>} Response promise with status
+ *
+ */
+export async function storeStakeAndBakeSignature({
+  signature,
+  typedData,
+  env,
+}: IStoreStakeAndBakeSignatureParams): Promise<IStoreStakeAndBakeSignatureStatus> {
+  const { baseApiUrl } = getApiConfig(env);
+
+  try {
+    const { data } = await axios.post<IStoreStakeAndBakeSignatureResponse>(
+      `${baseApiUrl}/api/v1/claimer/save-stake-and-bake-signature`,
+      null,
+      {
+        params: {
+          typed_data: typedData,
+          signature,
+        },
+      },
+    );
+
+    return data.status;
+  } catch (error) {
+    const errorMsg = getErrorMessage(error);
+
+    throw new Error(errorMsg);
+  }
+}

package/src/web3Sdk/getLBTCMintingFee/getLBTCMintingFee.stories.tsx

@@ -16,9 +16,9 @@ export default meta;
 
 type Story = StoryObj<typeof meta>;
 
-export const Sepolia: Story = {
+export const Holesky: Story = {
   args: {
-    chainId: OChainId.sepolia,
+    chainId: OChainId.holesky,
     bakeGasEstimate: 77,
   },
 };

package/src/web3Sdk/index.ts

@@ -1,15 +1,6 @@
-export * from '../sdk/getNetworkFeeSignature';
-export * from '../sdk/storeNetworkFeeSignature';
-export * from './approveLBTC';
-export * from './claimLBTC';
-export * from './getBasculeDepositStatus';
 export * from './getLBTCMintingFee';
-export * from './getLBTCTotalSupply';
-export * from './getPermitNonce';
-export * from './lbtcAddressConfig';
-export * from './lbtcOFTAdapterAddressConfig';
 export * from './signLbtcDestionationAddr';
 export * from './signNetworkFee';
-export * from './types';
-export * from './unstakeLBTC';
+export * from './signStakeAndBake';
+export * from './signStakeAndBake/config';
 

package/src/web3Sdk/signStakeAndBake/config.ts

@@ -0,0 +1,13 @@
+import { OChainId, TChainId } from '../../common/types/types';
+
+export const STAKE_AND_BAKE_SPENDER_ADDRESSES: Record<number, string> = {
+  [OChainId.holesky]: '0x52BD640617eeD47A00dA0da93351092D49208d1d',
+};
+
+export const getStakeAndBakeSpenderAddress = (chainId: TChainId): string => {
+  const address = STAKE_AND_BAKE_SPENDER_ADDRESSES[chainId];
+  if (!address) {
+    throw new Error(`No spender address configured for chain ID ${chainId}`);
+  }
+  return address;
+};

package/src/web3Sdk/signStakeAndBake/getTypedData.ts

@@ -0,0 +1,82 @@
+import { IEnvParam } from '../../common/types/internalTypes';
+import { TChainId } from '../../common/types/types';
+import { getPermitNonce } from '../getPermitNonce';
+import { getLbtcAddressConfig } from '../lbtcAddressConfig';
+
+export interface IStakeAndBakeTypedData extends IEnvParam {
+  chainId: TChainId;
+  expiryDate: number;
+  owner: string;
+  spender: string;
+  value: string;
+  rpcUrl?: string;
+}
+
+/**
+ * Generates EIP-712 typed data for stake and bake signature
+ *
+ * @param {IStakeAndBakeTypedData} params - Parameters for generating typed data
+ * @returns {object} The typed data object conforming to EIP-712
+ */
+export async function getStakeAndBakeTypedData({
+  chainId,
+  expiryDate,
+  owner,
+  spender,
+  value,
+  env,
+  rpcUrl,
+}: IStakeAndBakeTypedData) {
+  const lbtcAddresses = getLbtcAddressConfig(env);
+  const verifyingContract = lbtcAddresses[chainId];
+
+  const nonce = await getPermitNonce({
+    owner,
+    chainId,
+    rpcUrl,
+  });
+
+  return {
+    domain: {
+      name: 'Lombard Staked Bitcoin',
+      version: '1',
+      chainId,
+      verifyingContract,
+    },
+    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,
+      spender,
+      value,
+      nonce,
+      deadline: expiryDate.toString(),
+    },
+  };
+}

package/src/web3Sdk/signStakeAndBake/index.ts

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

package/src/web3Sdk/signStakeAndBake/signStakeAndBake.stories.tsx

@@ -0,0 +1,143 @@
+import { FormControl, InputLabel, MenuItem, Select } from '@mui/material';
+import type { Meta, StoryObj } from '@storybook/react';
+import { useState } from 'react';
+import { OChainId, OEnv } from '../../common/types/types';
+import { Button } from '../../stories/components/Button';
+import { CodeBlock } from '../../stories/components/CodeBlock';
+import { useConnect } from '../../stories/hooks/useConnect';
+import useQuery from '../../stories/hooks/useQuery';
+import { fromCamelCase } from '../../stories/utils/fromCamelCase';
+import { ISignStakeAndBakeParams, signStakeAndBake } from './signStakeAndBake';
+
+const { name } = signStakeAndBake;
+const nameWithWhitespaces = fromCamelCase(name);
+
+const EXPIRY_OPTIONS = {
+  '10 seconds': 10,
+  '1 minute': 60,
+  '1 hour': 3600,
+  '1 day': 86400,
+  '1 year': 31536000,
+} as const;
+
+type ExpiryOption = keyof typeof EXPIRY_OPTIONS;
+
+const meta = {
+  title: 'Web3SDK/signStakeAndBake',
+  component: StoryView,
+  tags: ['autodocs'],
+} satisfies Meta<typeof StoryView>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const WithParams: Story = {
+  args: {
+    env: OEnv.stage,
+  },
+};
+
+type SignStakeAndBakeProps = Pick<ISignStakeAndBakeParams, 'env'>;
+
+export function StoryView(props: SignStakeAndBakeProps) {
+  const [selectedExpiry, setSelectedExpiry] =
+    useState<ExpiryOption>('10 seconds');
+
+  const {
+    data: connectData,
+    error: connectError,
+    isLoading: isConnectLoading,
+    connect,
+  } = useConnect();
+
+  const request = async () => {
+    if (!connectData || !connectData.provider) {
+      return;
+    }
+
+    const chainId = OChainId.holesky;
+    const expiryDate =
+      Math.floor(Date.now() / 1000) + EXPIRY_OPTIONS[selectedExpiry];
+
+    return signStakeAndBake({
+      provider: connectData.provider,
+      address: connectData.account,
+      chainId,
+      env: props.env,
+      value: '1999',
+      expiryDate,
+    });
+  };
+
+  const { data, error, isLoading, refetch } = useQuery(
+    request,
+    [selectedExpiry],
+    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.
+      </p>
+
+      <div className="mb-4">
+        <Button
+          onClick={connect}
+          disabled={isConnectLoading}
+          isLoading={isConnectLoading}
+        >
+          Connect
+        </Button>
+
+        <CodeBlock text={connectError || formattedConnectData} />
+      </div>
+
+      <div className="mb-4">
+        <FormControl fullWidth>
+          <InputLabel id="expiry-select-label">Expiry Time</InputLabel>
+          <Select
+            labelId="expiry-select-label"
+            value={selectedExpiry}
+            label="Expiry Time"
+            onChange={e => setSelectedExpiry(e.target.value as ExpiryOption)}
+          >
+            {Object.keys(EXPIRY_OPTIONS).map(option => (
+              <MenuItem key={option} value={option}>
+                {option}
+              </MenuItem>
+            ))}
+          </Select>
+        </FormControl>
+      </div>
+
+      <Button
+        onClick={refetch}
+        disabled={
+          isLoading || !connectData || connectData.chainId !== OChainId.holesky
+        }
+        isLoading={isLoading}
+      >
+        {nameWithWhitespaces}
+      </Button>
+
+      <CodeBlock
+        text={
+          error ||
+          (data && {
+            ...data,
+            signature: data.signature,
+            typedData: data.typedData ? JSON.parse(data.typedData) : '',
+          })
+        }
+      />
+    </>
+  );
+}

package/src/web3Sdk/signStakeAndBake/signStakeAndBake.ts

@@ -0,0 +1,99 @@
+import { IEnvParam } from '../../common/types/internalTypes';
+import { TChainId } from '../../common/types/types';
+import { Provider } from '../../provider';
+import { IProviderBasedParams } from '../types';
+import { getStakeAndBakeSpenderAddress } from './config';
+import { getStakeAndBakeTypedData } from './getTypedData';
+
+const NO_SIGNATURE_ERROR =
+  'Failed to obtain a valid signature. The response is undefined or invalid.';
+
+export interface ISignStakeAndBakeParams
+  extends Pick<IProviderBasedParams, 'provider'>,
+    IEnvParam {
+  /**
+   * The address to sign with (owner)
+   */
+  address: string;
+  /**
+   * Chain ID for the signature
+   */
+  chainId: TChainId;
+  /**
+   * The value to approve
+   */
+  value: string;
+  /**
+   * Expiry date in seconds
+   */
+  expiryDate: number;
+  /**
+   * Optional RPC URL for the network
+   */
+  rpcUrl?: string;
+}
+
+export interface ISignStakeAndBakeResult {
+  /**
+   * The signature
+   */
+  signature: string;
+  /**
+   * The typed data used to generate the signature
+   */
+  typedData: string;
+}
+
+/**
+ * Signs stake and bake authorization with EIP-712
+ *
+ * @param {ISignStakeAndBakeParams} params - Parameters for signing
+ * @returns {Promise<ISignStakeAndBakeResult>} The signature and typed data
+ */
+export async function signStakeAndBake({
+  address,
+  provider,
+  chainId,
+  value,
+  env,
+  expiryDate,
+  rpcUrl,
+}: ISignStakeAndBakeParams): Promise<ISignStakeAndBakeResult> {
+  const providerInstance = new Provider({
+    provider,
+    account: address,
+    chainId,
+  });
+
+  const spender = getStakeAndBakeSpenderAddress(chainId);
+
+  const typedDataObject = await getStakeAndBakeTypedData({
+    chainId,
+    expiryDate,
+    owner: address,
+    spender,
+    value,
+    env,
+    rpcUrl,
+  });
+
+  const typedData = JSON.stringify(typedDataObject);
+
+  const signature = await providerInstance.web3?.currentProvider?.request<
+    'eth_signTypedData_v4',
+    string
+  >({
+    method: 'eth_signTypedData_v4',
+    params: [address, typedData],
+  });
+
+  if (typeof signature === 'string') {
+    return { signature, typedData };
+  }
+
+  if (!signature?.result) {
+    throw new Error(NO_SIGNATURE_ERROR);
+  }
+
+  return { signature: signature.result, typedData };
+}