@lombard.finance/sdk-starknet 0.3.0-canary.2

package/src/utils/wallet-account.ts

@@ -0,0 +1,9 @@
+import { WalletAccount } from 'starknet';
+
+export type WalletAccountParameters = {
+  /** The starknet wallet account object */
+  walletAccount: WalletAccount;
+};
+
+/** Known wallets */
+export type WalletName = 'Braavos' | 'Argent X' | 'Keplr' | 'OKX Wallet';

package/src/wallet-functions/sign-message.stories.tsx

@@ -0,0 +1,72 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { useEffect } from 'react';
+
+import { Button } from '../stories/components/Button';
+import { CodeBlock } from '../stories/components/CodeBlock';
+import { ConnectButton } from '../stories/components/ConnectButton';
+import { functionType } from '../stories/components/decorators';
+import { starknetContext } from '../stories/components/decorators/starknet-context';
+import { useConnection } from '../stories/hooks/use-connection';
+import useQuery from '../stories/hooks/use-query';
+import { makeDestinationChainId,StarknetChainId } from '../utils/chains';
+import { signMessage } from './sign-message';
+
+const meta = {
+  title: 'write/sign-message',
+  component: StoryView,
+  tags: ['autodocs'],
+  decorators: [functionType('write'), starknetContext()],
+} satisfies Meta<typeof StoryView>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const WithParams: Story = {
+  args: {
+    message: `destination chain id is ${makeDestinationChainId(StarknetChainId.SN_SEPOLIA)}`,
+    chainId: StarknetChainId.SN_SEPOLIA,
+  },
+};
+
+type FuncParameters = Parameters<typeof signMessage>[0];
+type Props = Omit<FuncParameters, 'walletAccount'>;
+
+export function StoryView(props: Props) {
+  const { account } = useConnection();
+
+  useEffect(() => {
+    console.log('s account', account);
+  }, [account]);
+
+  const request = async () => {
+    if (!account) {
+      console.info('Cannot perform action');
+      return;
+    }
+
+    return signMessage({
+      walletAccount: account,
+      ...props,
+    });
+  };
+
+  const { data, error, isLoading, refetch } = useQuery(request, [], false);
+
+  return (
+    <>
+      <div className="mb-4">
+        <ConnectButton desiredChainId={props.chainId} />
+      </div>
+
+      <Button
+        onClick={refetch}
+        disabled={isLoading}
+        isLoading={isLoading}
+        actionName={signMessage.name}
+      />
+
+      <CodeBlock text={error || data} />
+    </>
+  );
+}

package/src/wallet-functions/sign-message.ts

@@ -0,0 +1,127 @@
+import { ec, Signature, typedData, WalletAccount } from 'starknet';
+
+import { getPublicKey, recoverFullPublicKeys } from '../utils/account';
+import {
+  ChainParameters,
+  makeDestinationChainId,
+  StarknetChainId,
+} from '../utils/chains';
+import { Address } from '../utils/common';
+import { getRpcProvider } from '../utils/rpc-providers';
+import { normalizeSignature } from '../utils/signature';
+import { SIGN_MESSAGE_TYPED_DATA } from '../utils/typed-data';
+import { WalletName } from '../utils/wallet-account';
+
+type SignMessageParameters = {
+  message: string;
+  walletAccount: WalletAccount;
+} & ChainParameters;
+
+type SignMessageResult = {
+  /** The signing account address */
+  account: string;
+  /** The message hash */
+  hash: string;
+  /** The raw signature */
+  signature: Signature;
+  /** The signature (compact hex format) or Ethereum signature hex string */
+  signatureHex: string;
+  /** The signing account pubkey */
+  pubKey: string;
+  typedData: unknown;
+  /** A flag indicating whether the signature was verified on-chain */
+  verifiedOnChain: boolean;
+  verifiedOffChain:
+    | {
+        /** Recovered full pubkey */
+        fullPubKey: string;
+        /** A flag indicating whether the signature was verified off-chain */
+        verified: boolean;
+      }[]
+    | undefined;
+};
+
+export async function signMessage({
+  message,
+  walletAccount,
+  chainId = StarknetChainId.SN_MAIN,
+}: SignMessageParameters): Promise<SignMessageResult> {
+  const personalMessageTypedData = SIGN_MESSAGE_TYPED_DATA(chainId, message);
+  const skipVerify = process.env.SKIP_STARKNET_VERIFY === 'true';
+
+  if (walletAccount.walletProvider.name.toLowerCase().includes('kelpr')) {
+    console.warn('Keplr wallet is not fully supported.');
+  }
+
+  const hashMsg = await walletAccount.hashMessage(personalMessageTypedData);
+  const signature = await walletAccount.signMessage(personalMessageTypedData);
+
+  // Use SDK's RPC provider for read-only operations to avoid wallet RPC rate limits
+  // (Wallet extensions like Braavos/ArgentX use OnFinality which has strict rate limits)
+  const rpcProvider = getRpcProvider(chainId);
+  const pubKey = await getPublicKey(
+    walletAccount.address as Address,
+    rpcProvider,
+  );
+
+  let verifiedOnChain = false;
+  if (!skipVerify) {
+    const provider = getRpcProvider(chainId);
+    verifiedOnChain = await provider.verifyMessageInStarknet(
+      hashMsg,
+      signature,
+      walletAccount.address,
+    );
+  }
+
+  const rs = normalizeSignature(
+    signature,
+    walletAccount.walletProvider.name as WalletName,
+  );
+
+  let verifiedOffChain = undefined;
+
+  if (rs instanceof ec.starkCurve.Signature) {
+    const fullPubKeys = recoverFullPublicKeys(rs, hashMsg);
+
+    verifiedOffChain = fullPubKeys.map(fpk => {
+      return {
+        fullPubKey: fpk,
+        verified: typedData.verifyMessage(hashMsg, rs, fpk),
+      };
+    });
+
+    const tfpk = verifiedOffChain.find(x =>
+      x.fullPubKey.includes(pubKey.slice(2)),
+    );
+    if (tfpk) verifiedOffChain = [tfpk];
+  }
+
+  return {
+    hash: hashMsg,
+    typedData: personalMessageTypedData,
+    signature,
+    signatureHex:
+      rs instanceof ec.starkCurve.Signature ? `0x${rs.toCompactHex()}` : rs,
+    account: `0x${walletAccount.address.slice(2).padStart(64, '0')}`,
+    pubKey,
+    verifiedOnChain,
+    verifiedOffChain,
+  };
+}
+
+type SignLbtcDestinationAddrStarknetParameters = Omit<
+  SignMessageParameters,
+  'message'
+>;
+
+export async function signLbtcDestinationAddrStarknet({
+  walletAccount,
+  chainId = StarknetChainId.SN_MAIN,
+}: SignLbtcDestinationAddrStarknetParameters) {
+  return signMessage({
+    walletAccount,
+    chainId,
+    message: `destination chain id is ${makeDestinationChainId(chainId)}`,
+  });
+}

package/src/wallet-functions/sign-terms-of-service.ts

@@ -0,0 +1,45 @@
+import { WalletAccount } from 'starknet';
+
+import { ChainParameters, StarknetChainId } from '../utils/chains';
+import { signMessage } from './sign-message';
+
+const SIGN_MESSAGE =
+  'I have read and agreed to the terms of service: https://docs.lombard.finance/legals/terms-of-service';
+
+interface SignTermsOfServiceParams extends ChainParameters {
+  walletAccount: WalletAccount;
+}
+
+/**
+ * Signs terms of service for Starknet.
+ *
+ * @param {SignTermsOfServiceParams} params - Parameters including wallet account and chain ID
+ * @returns {Promise<{ signature: string; signatureHex: string; account: string; pubKey: string }>} The signature details
+ */
+export async function signTermsOfService({
+  walletAccount,
+  chainId = StarknetChainId.SN_MAIN,
+}: SignTermsOfServiceParams): Promise<{
+  signature: string;
+  signatureHex: string;
+  account: string;
+  pubKey: string;
+}> {
+  const result = await signMessage({
+    message: SIGN_MESSAGE,
+    walletAccount,
+    chainId,
+  });
+
+  // Convert signature array to string format expected by backend
+  const signatureString = Array.isArray(result.signature)
+    ? JSON.stringify(result.signature)
+    : result.signature.toString();
+
+  return {
+    signature: signatureString,
+    signatureHex: result.signatureHex,
+    account: result.account,
+    pubKey: result.pubKey,
+  };
+}