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

package/src/tokens/lib/tokens.ts

@@ -0,0 +1,267 @@
+import { DEFAULT_ENV, Env } from '@lombard.finance/sdk-common';
+import { Contract, TypedContractV2 } from 'starknet';
+
+import { ChainParameters, StarknetChainId } from '../../utils/chains';
+import { EnvParameters } from '../../utils/env';
+import { ERR_CHAIN_MISMATCH, ERR_NO_PROVIDER, ERR_NO_TOKEN } from '../../utils/err';
+import { getRpcProvider, ProviderParameters } from '../../utils/rpc-providers';
+import ERC20_ABI from '../abi/ERC20_ABI';
+import LBTC_ABI from '../abi/LBTC_ABI';
+import LBTC_BASCULE_ABI from '../abi/LBTC_BASCULE_ABI';
+import LBTC_BRIDGE_ABI from '../abi/LBTC_BRIDGE_ABI';
+
+export enum Token {
+  ETH = 'ETH',
+  LBTC = 'LBTC',
+  STRK = 'STRK',
+}
+
+const ETH_TOKEN_CONFIG = {
+  [StarknetChainId.SN_SEPOLIA]: {
+    address:
+      '0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7',
+    classHash:
+      '0x076791ef97c042f81fbf352ad95f39a22554ee8d7927b2ce3c681f3418b5206a',
+    abi: ERC20_ABI,
+  },
+  [StarknetChainId.SN_MAIN]: {
+    address:
+      '0x049D36570D4e46f48e99674bd3fcc84644DdD6b96F7C741B1562B82f9e004dC7',
+    classHash: '',
+    abi: ERC20_ABI,
+  },
+} as const;
+
+const LBTC_TOKEN_CONFIG = {
+  [Env.stage]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x00b442f5420860e937a99659326e81a97e07bfd538b3cee65b90029c9da38a5f',
+      classHash:
+        '0x01f12942315b6dd05a21392ced7890a380affa81066741de6ac31af4dcb0d468',
+      abi: LBTC_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.testnet]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x00456a829ab75ba5e97534dc70d7fc617cfda244f8dcda47b11624de67c6e70c',
+      classHash:
+        '0x01f12942315b6dd05a21392ced7890a380affa81066741de6ac31af4dcb0d468',
+      abi: LBTC_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.dev]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x0723de0c550b7bfbb5051dade72966d71a08bef952c0197462a5244497eb57c1',
+      classHash:
+        '0x01f12942315b6dd05a21392ced7890a380affa81066741de6ac31af4dcb0d468',
+      abi: LBTC_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.prod]: {
+    [StarknetChainId.SN_SEPOLIA]: undefined,
+    [StarknetChainId.SN_MAIN]: {
+      address:
+        '0x036834a40984312f7f7de8d31e3f6305b325389eaeea5b1c0664b2fb936461a4',
+      classHash: '',
+      abi: LBTC_ABI,
+    },
+  },
+  [Env.ibc]: undefined,
+} as const;
+
+const LBTC_BRIDGE_CONFIG = {
+  [Env.stage]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x01d27f156092746d0d7cd9d9deec5e937f27c3c7c1c28365e9e5efac459880b3',
+      classHash:
+        '0x0524d80f999f690bbb302f37a36abdf82ea2135391c3d1a5090e7665c20e2159',
+      abi: LBTC_BRIDGE_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.testnet]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x063b7b5c8b114ebd5b9602fbd5d0ffd2cc3a598f1d91c6904cc0997cd8fea760',
+      classHash:
+        '0x0524d80f999f690bbb302f37a36abdf82ea2135391c3d1a5090e7665c20e2159',
+      abi: LBTC_BRIDGE_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.dev]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x04838a05c798dc57e01e85526979841c84f1f3c732a525cff53adb3e8bee3d24',
+      classHash:
+        '0x0524d80f999f690bbb302f37a36abdf82ea2135391c3d1a5090e7665c20e2159',
+      abi: LBTC_BRIDGE_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.prod]: {
+    [StarknetChainId.SN_SEPOLIA]: undefined,
+    [StarknetChainId.SN_MAIN]: {
+      address:
+        '0x05b1886d0f844ab930fc0ee066f1655a873437f15a5d2c41ee3e884fd5299976',
+      classHash: '',
+      abi: LBTC_BRIDGE_ABI,
+    },
+  },
+  [Env.ibc]: undefined,
+} as const;
+
+const LBTC_BASCULE_CONFIG = {
+  [Env.stage]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x001d16d02a4ed6f5673635b1ad3b27ead190904b83fafde7b4c55282ef57492a',
+      classHash:
+        '0x0083965992f591e5979068d8a12a09a1f13949e1d1f65f495e7a5503d2f1e519',
+      abi: LBTC_BASCULE_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.testnet]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x01757fb630a6cc4e3607fc1d92e0f91c5b3eedd71420f1fa7dc6d1764827b012',
+      classHash:
+        '0x0083965992f591e5979068d8a12a09a1f13949e1d1f65f495e7a5503d2f1e519',
+      abi: LBTC_BASCULE_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.dev]: {
+    [StarknetChainId.SN_SEPOLIA]: {
+      address:
+        '0x01757fb630a6cc4e3607fc1d92e0f91c5b3eedd71420f1fa7dc6d1764827b012',
+      classHash:
+        '0x0083965992f591e5979068d8a12a09a1f13949e1d1f65f495e7a5503d2f1e519',
+      abi: LBTC_BASCULE_ABI,
+    },
+    [StarknetChainId.SN_MAIN]: undefined,
+  },
+  [Env.prod]: {
+    [StarknetChainId.SN_SEPOLIA]: undefined,
+    [StarknetChainId.SN_MAIN]: {
+      address:
+        '0x76b68231c1bddb7c981c5a19d9c6a28c5cb14161b8fcd3a857aa8a396d31f95',
+      classHash: '',
+      abi: LBTC_BASCULE_ABI,
+    },
+  },
+  [Env.ibc]: undefined,
+} as const;
+
+const STRK_TOKEN_CONFIG = {
+  [StarknetChainId.SN_SEPOLIA]: {
+    address:
+      '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',
+    classHash:
+      '0x009524a94b41c4440a16fd96d7c1ef6ad6f44c1c013e96662734502cd4ee9b1f',
+    abi: ERC20_ABI,
+  },
+  [StarknetChainId.SN_MAIN]: {
+    address:
+      '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',
+    classHash:
+      '0x009524a94b41c4440a16fd96d7c1ef6ad6f44c1c013e96662734502cd4ee9b1f',
+    abi: ERC20_ABI,
+  },
+} as const;
+
+export const getTokenInfo = (
+  token: Token,
+  chain: StarknetChainId = StarknetChainId.SN_MAIN,
+  contractType: 'token' | 'bridge' | 'bascule' = 'token',
+  env = DEFAULT_ENV,
+) => {
+  if (contractType === 'bridge') {
+    switch (token) {
+      case Token.LBTC:
+        return LBTC_BRIDGE_CONFIG?.[env]?.[chain];
+      default:
+        return undefined;
+    }
+  }
+
+  if (contractType === 'bascule') {
+    switch (token) {
+      case Token.LBTC:
+        return LBTC_BASCULE_CONFIG?.[env]?.[chain];
+      default:
+        return undefined;
+    }
+  }
+
+  // token contracts
+
+  switch (token) {
+    case Token.ETH:
+      return ETH_TOKEN_CONFIG[chain];
+    case Token.LBTC:
+      return LBTC_TOKEN_CONFIG?.[env]?.[chain];
+    case Token.STRK:
+      return STRK_TOKEN_CONFIG[chain];
+  }
+};
+
+export type TokenParameters = {
+  /** The token identifier. */
+  token: Token;
+};
+
+/**
+ * Gets the token contract
+ *
+ * @throws ERR_CHAIN_MISMATCH if wallet network doesn't match SDK environment
+ * @throws ERR_NO_TOKEN if token is not configured for the given chain/env
+ * @throws ERR_NO_PROVIDER if no provider is available
+ */
+export const getTokenContract = ({
+  token,
+  chainId,
+  provider: _provider,
+  contractType = 'token',
+  env,
+}: TokenParameters &
+  ChainParameters &
+  ProviderParameters &
+  EnvParameters & {
+    contractType: 'token' | 'bridge' | 'bascule';
+  }) => {
+  const tokenInfo = getTokenInfo(token, chainId, contractType, env);
+  if (!tokenInfo) {
+    // Check for chain/env mismatch and provide a more helpful error message
+    // This happens when the wallet is connected to a different network than the SDK expects
+    const isProd = env === 'prod';
+    const isMainnet = chainId === StarknetChainId.SN_MAIN;
+
+    // If env is prod but wallet is on testnet, or env is testnet but wallet is on mainnet
+    if ((isProd && !isMainnet) || (!isProd && isMainnet)) {
+      throw ERR_CHAIN_MISMATCH(chainId ?? 'unknown', env ?? 'unknown');
+    }
+
+    throw ERR_NO_TOKEN(token);
+  }
+
+  const provider = _provider || getRpcProvider(chainId);
+  if (!provider) {
+    throw ERR_NO_PROVIDER(chainId);
+  }
+
+  const contract = new Contract(
+    tokenInfo.abi,
+    tokenInfo.address,
+    provider,
+  ) as TypedContractV2<typeof tokenInfo.abi>;
+  return contract;
+};

package/src/utils/account.ts

@@ -0,0 +1,81 @@
+import { num, RpcProvider, WalletAccount } from 'starknet';
+
+import { StarknetChainId } from './chains';
+import { Address } from './common';
+import { ERR_NO_PUBKEY } from './err';
+import { NormalizedSignature } from './signature';
+
+/** The list of entrypoints that could be the public key getters */
+const PUBLIC_KEY_GETTERS = [
+  /** The default IAccount<T> public key getter */
+  'public_key',
+  /** The Braavos wallet account contract public key getter */
+  'get_public_key',
+  /** The Argent wallet account contract public key getter */
+  'get_owner',
+  /** The OKX wallet account contract public key getters */
+  'getSigner',
+];
+
+/** Gets the public key of an account stored in a contract */
+export async function getPublicKey(
+  accountAddress: Address,
+  provider: RpcProvider | WalletAccount,
+) {
+  let pubkey: string | undefined = undefined;
+
+  const chainId = (await provider.getChainId()) as StarknetChainId;
+
+  for (const entrypoint of PUBLIC_KEY_GETTERS) {
+    try {
+      const res = await provider.callContract({
+        contractAddress: accountAddress,
+        entrypoint,
+      });
+
+      if (num.isHex(res[0])) {
+        pubkey = res[0];
+      }
+    } catch {
+      // NOOP
+    }
+  }
+
+  if (!pubkey) {
+    throw ERR_NO_PUBKEY(accountAddress, chainId);
+  }
+
+  return pubkey;
+}
+
+/**
+ * Recovers the full public key from the given signature and signed message hash
+ */
+export function recoverFullPublicKeys(
+  signature: NormalizedSignature,
+  hash: string,
+) {
+  const recoveryBits = [0, 1];
+
+  const keys = [];
+  try {
+    for (const bit of recoveryBits) {
+      const rs = signature.addRecoveryBit(bit);
+      const recovered = rs
+        .recoverPublicKey(feltToUint8Array(hash))
+        .toHex(false);
+      keys.push(`0x${recovered}`);
+    }
+  } catch {
+    // NOOP
+  }
+
+  return keys;
+}
+
+function feltToUint8Array(felt: string | bigint): Uint8Array {
+  const value = typeof felt === 'bigint' ? felt : BigInt(felt);
+  let hexValue = value.toString(16);
+  if (hexValue.length % 2) hexValue = `0${hexValue}`; // Ensure even-length
+  return Uint8Array.from(Buffer.from(hexValue, 'hex'));
+}

package/src/utils/chains.ts

@@ -0,0 +1,33 @@
+import BigNumber from 'bignumber.js';
+
+/** Starknet Main (mainnet) chain id */
+const SN_MAIN = '0x534e5f4d41494e' as const;
+/** Starknet Sepolia chain id */
+const SN_SEPOLIA = '0x534e5f5345504f4c4941' as const;
+
+/** Prefixes the destination chain with 0x04... */
+export function makeDestinationChainId(chainId: `0x${string}`) {
+  const ch = BigInt(chainId);
+  const ch64 = `0x04${ch.toString(16).padStart(64, '0').slice(2)}`;
+  return BigNumber(ch64).toFixed(0);
+}
+
+/** Starknet chain id */
+export const StarknetChainId = {
+  SN_MAIN: SN_MAIN,
+  SN_SEPOLIA: SN_SEPOLIA,
+} as const;
+
+export type StarknetChainId =
+  (typeof StarknetChainId)[keyof typeof StarknetChainId];
+
+/** Starknet chain identifier (human readable). */
+export enum StarknetChain {
+  Mainnet = 'starknet:mainnet',
+  Sepolia = 'starknet:sepolia',
+}
+
+export type ChainParameters = {
+  /** The starknet chain identifier. */
+  chainId?: StarknetChainId;
+};

package/src/utils/common.ts

@@ -0,0 +1,11 @@
+export type Hex = `0x${string}`;
+export type Hash = Hex;
+export type Address = Hash;
+
+export function isHex(input: string): input is Hex {
+  return input.startsWith('0x');
+}
+
+export function ensureHex(input: string): Hex {
+  return isHex(input) ? input : `0x${input}`;
+}

package/src/utils/env.ts

@@ -0,0 +1,6 @@
+import { Env } from '@lombard.finance/sdk-common';
+
+export type EnvParameters = {
+  /** The (optional) env. */
+  env?: Env;
+};

package/src/utils/err.ts

@@ -0,0 +1,121 @@
+import { extractErrorMessage } from '@lombard.finance/sdk-common/utils/err';
+
+import { Token } from '../tokens/lib/tokens';
+import { StarknetChainId } from './chains';
+
+/** ErrorOptions type for ES2022 compatibility */
+interface ErrorOptions {
+  cause?: unknown;
+}
+
+enum ErrorCode {
+  NO_PROVIDER = 'NO_PROVIDER',
+  NO_TOKEN = 'NO_TOKEN',
+  UNSUPPORTED_TOKEN = 'UNSUPPORTED_TOKEN',
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR',
+  NO_STARKNET_WINDOW_OBJECT = 'NO_STARKNET_WINDOW_OBJECT',
+  NO_PUBKEY = 'NO_PUBKEY',
+  UNKNOWN_SIGNATURE_FORMAT = 'UNKNOWN_SIGNATURE_FORMAT',
+  UNEXPECTED_OUTPUT_SCRIPT = 'UNEXPECTED_OUTPUT_SCRIPT',
+  UNSUPPORTED_WALLET = 'UNSUPPORTED_WALLET',
+  CHAIN_MISMATCH = 'CHAIN_MISMATCH',
+}
+
+export class StarknetSdkError extends Error {
+  /** The cause of the error (for error chaining) */
+  cause?: unknown;
+
+  constructor(
+    /** The error message */
+    message: string,
+    /** The error code */
+    readonly code: ErrorCode | string,
+    /** The optional error options */
+    options?: ErrorOptions,
+  ) {
+    super(message);
+    this.name = 'StarknetSdkError';
+    if (options?.cause) {
+      this.cause = options.cause;
+    }
+  }
+
+  static wrap(
+    error: unknown,
+    code = ErrorCode.UNKNOWN_ERROR,
+    customMessage = 'Unknown error occurred.',
+  ) {
+    if (error instanceof StarknetSdkError) return error;
+
+    const message = extractErrorMessage(error);
+    const options: ErrorOptions | undefined =
+      error instanceof Error ? { cause: error } : undefined;
+
+    return new StarknetSdkError(message || customMessage, code, options);
+  }
+}
+
+export const ERR_NO_PROVIDER = (chainId: StarknetChainId | undefined) =>
+  new StarknetSdkError(
+    `Could not determine the RPC provider for given chain: ${chainId || 'undefined'}`,
+    ErrorCode.NO_PROVIDER,
+  );
+
+export const ERR_NO_TOKEN = (token: Token | undefined) =>
+  new StarknetSdkError(
+    `Could not retrieve the token information for given token: ${token || 'undefined'}`,
+    ErrorCode.NO_TOKEN,
+  );
+
+export const ERR_UNSUPPORTED_TOKEN = (token: Token | undefined) =>
+  new StarknetSdkError(
+    `The token ${token || 'undefined'} is not supported.`,
+    ErrorCode.UNSUPPORTED_TOKEN,
+  );
+
+export const ERR_NO_STARKNET_WINDOW_OBJECT = () =>
+  new StarknetSdkError(
+    'No Starknet window object detected',
+    ErrorCode.NO_STARKNET_WINDOW_OBJECT,
+  );
+
+export const ERR_NO_PUBKEY = (account: string, chainId: StarknetChainId) =>
+  new StarknetSdkError(
+    `Could not retrieve pubKey for ${account} on ${chainId}`,
+    ErrorCode.NO_PUBKEY,
+  );
+
+export const ERR_UNKNOWN_SIGNATURE_FORMAT = () =>
+  new StarknetSdkError(
+    'Unknown signature format, known formats are [r, s], [version, r, s], [version, type, r, s, ...]',
+    ErrorCode.UNKNOWN_SIGNATURE_FORMAT,
+  );
+
+export const ERR_UNEXPECTED_OUTPUT_SCRIPT = () =>
+  new StarknetSdkError(
+    'The output script for provided BTC address is invalid',
+    ErrorCode.UNEXPECTED_OUTPUT_SCRIPT,
+  );
+
+export const ERR_UNSUPPORTED_WALLET = (walletName?: string) =>
+  new StarknetSdkError(
+    `The wallet ${walletName || ''} is not supported`,
+    ErrorCode.UNSUPPORTED_WALLET,
+  );
+
+export const ERR_CHAIN_MISMATCH = (
+  walletChainId: StarknetChainId | string,
+  expectedEnv: string,
+) => {
+  const walletNetwork =
+    walletChainId === '0x534e5f4d41494e'
+      ? 'Starknet Mainnet'
+      : walletChainId === '0x534e5f5345504f4c4941'
+        ? 'Starknet Sepolia'
+        : `unknown chain (${walletChainId})`;
+  const expectedNetwork = expectedEnv === 'prod' ? 'Starknet Mainnet' : 'Starknet Sepolia';
+  return new StarknetSdkError(
+    `Wallet network mismatch: Your wallet is connected to ${walletNetwork}, but the SDK is configured for ${expectedNetwork}. Please switch your wallet to ${expectedNetwork}.`,
+    ErrorCode.CHAIN_MISMATCH,
+  );
+};

package/src/utils/rpc-providers.ts

@@ -0,0 +1,25 @@
+import { RpcProvider, WalletAccount } from 'starknet';
+
+import { StarknetChainId } from './chains';
+
+const RPC_PROVIDERS = {
+  [StarknetChainId.SN_MAIN]: 'https://rpc.starknet.lava.build:443',
+  [StarknetChainId.SN_SEPOLIA]: 'https://rpc.starknet-testnet.lava.build:443',
+};
+
+const providers = new Map<StarknetChainId, RpcProvider>();
+export const getRpcProvider = (
+  chainId: StarknetChainId = StarknetChainId.SN_MAIN,
+) => {
+  let provider = providers.get(chainId);
+  if (!provider) {
+    provider = new RpcProvider({ nodeUrl: RPC_PROVIDERS[chainId] });
+    providers.set(chainId, provider);
+  }
+
+  return provider;
+};
+
+export type ProviderParameters = {
+  provider: RpcProvider | WalletAccount;
+};

package/src/utils/signature.ts

@@ -0,0 +1,60 @@
+import { ArraySignatureType, ec, WeierstrassSignatureType } from 'starknet';
+
+import { ERR_UNKNOWN_SIGNATURE_FORMAT, ERR_UNSUPPORTED_WALLET } from './err';
+import { WalletName } from './wallet-account';
+
+export type NormalizedSignature = WeierstrassSignatureType;
+
+export function normalizeSignature(
+  signature: ArraySignatureType,
+  walletName?: WalletName,
+): NormalizedSignature {
+  let sigR = undefined;
+  let sigS = undefined;
+
+  if (signature.length === 2) {
+    // [r, s] (raw OpenZeppelin or starknet.js)
+    const [r, s] = signature;
+    sigR = r;
+    sigS = s;
+  } else if (
+    walletName === 'Braavos' ||
+    (signature.length === 3 && signature[0] === '1')
+  ) {
+    // Braavos: [version, r, s]
+    const [_version, r, s] = signature;
+    sigR = r;
+    sigS = s;
+  } else if (
+    walletName === 'Keplr' ||
+    (signature.length === 5 &&
+      signature.filter(x => x.startsWith('0x')).length === 5)
+  ) {
+    // Probably Keplr: [r low, r high, s low, s high, version]
+
+    throw ERR_UNSUPPORTED_WALLET(walletName);
+  } else {
+    // Argent X: [number of signers, type, pubkey, r, s, ...]
+    // https://docs.argent.xyz/aa-use-cases/verifying-signatures-and-cosigners#verifying-multi-signatures
+    const [
+      _signers,
+      _signerType1,
+      _pubkey1,
+      r1,
+      s1,
+      _signerType2,
+      _pubkey2,
+      _r2,
+      _s2,
+    ] = signature;
+    sigR = r1;
+    sigS = s1;
+  }
+
+  if (sigR && sigS) {
+    const sig = new ec.starkCurve.Signature(BigInt(sigR), BigInt(sigS));
+    return sig;
+  }
+
+  throw ERR_UNKNOWN_SIGNATURE_FORMAT;
+}

package/src/utils/span.ts

@@ -0,0 +1,56 @@
+import { uint256 } from 'starknet';
+
+// Example of the proof hex:
+// 0x
+// 0000000000000000000000000000000000000000000000000000000000000020  //index: 0; offset 0x20 -> 32/32 -> 1
+// 0000000000000000000000000000000000000000000000000000000000000004  //index: 1; len 0x4 -> 4
+// 0000000000000000000000000000000000000000000000000000000000000080  //index: 2; el 0: 0x80 -> 128/32 -> 4 +3
+// 00000000000000000000000000000000000000000000000000000000000000e0  //index: 3; el 1: 0xe0 -> 224/32 -> 7 +3
+// 0000000000000000000000000000000000000000000000000000000000000140  //index: 4; el 2: 0x140 -> 320/32 -> 10 +3
+// 00000000000000000000000000000000000000000000000000000000000001a0  //index: 5; el 3: 0x1a0 -> 416/32 -> 13 +3
+// 0000000000000000000000000000000000000000000000000000000000000040  //index: 6;
+// 195a8c89950230b7f0e204dad96026e7fbc3e871c5e36179d3398e0b71d93a6b  //index: 7; tuple 1
+// 12f0bc183214345ec0931a02f1798230da7ba0735176cb203342e34086ecd9c7  //index: 8;
+// 0000000000000000000000000000000000000000000000000000000000000040  //index: 9;
+// e57eb39fad14be8803853f9dce2a1aeb13e8e6a7e4b4762601469c4cefee05e6  //index: 10; tuple 2
+// 1ad93c8fb90e282f6e41aaaca23d0ddc088fdd2da26188d0f89c0049c16f6fa4  //index: 11;
+// 0000000000000000000000000000000000000000000000000000000000000040  //index: 10;
+// 3b8cc5c7440647ee1345785a4167d8b119ecd7a0315ec4e112ae27e7cd7f8e36  //index: 13; tuple 3
+// 6093f2edd4a8b54d28ecc26b595402f63cfd90b76f329e37d8d48eb0c64a353e  //index: 14;
+// 0000000000000000000000000000000000000000000000000000000000000040  //index: 15;
+// 65b8ea7c620f8b206e94e4b0415cb29ae049c13147593895ff33fcf1ab871345  //index: 16; tuple 4
+// 3bd0794b51ae3db9c8c90a89c7843150c812c119f7faa9997d0a942253e7cb4c  //index: 17;
+
+export function parseProofHexToU256Tuples(proofHex: string) {
+  let calldataHex = proofHex;
+  if (calldataHex.startsWith('0x')) calldataHex = calldataHex.slice(2);
+  const words = calldataHex.match(/.{64}/g); // each word = 32 bytes = 64 hex chars
+  if (!words) throw new Error('Invalid hex string');
+
+  const offsetToArray = Number.parseInt(words[0], 16) / 32;
+  const arrayLength = Number.parseInt(words[offsetToArray], 16);
+  const offsetBase = offsetToArray + 1; // where offsets to elements start
+
+  const result = [];
+
+  for (let i = 0; i < arrayLength; i++) {
+    const tupleByteOffset = Number.parseInt(words[offsetBase + i], 16); // in bytes
+
+    // Dynamic tuple layout:
+    // [0]: skip
+    // [1]: u256 low
+    // [2]: u256 high
+    const skip = 1;
+    const tupleWordIndex = tupleByteOffset / 32 + offsetBase + skip;
+
+    const r = `0x${words[tupleWordIndex]}`;
+    const s = `0x${words[tupleWordIndex + 1]}`;
+
+    const uint256r = uint256.bnToUint256(r);
+    const uint256s = uint256.bnToUint256(s);
+
+    result.push({ 0: uint256r, 1: uint256s });
+  }
+
+  return result;
+}

package/src/utils/typed-data.ts

@@ -0,0 +1,36 @@
+import { TypedData, TypedDataRevision } from 'starknet';
+
+import { StarknetChainId } from './chains';
+
+export const SIGN_MESSAGE_TYPED_DATA = (
+  chainId: StarknetChainId,
+  message: string,
+): TypedData => ({
+  types: {
+    PersonalMessage: [{ name: 'message', type: 'string' }],
+    StarknetDomain: [
+      {
+        name: 'name',
+        type: 'shortstring',
+      },
+      {
+        name: 'chainId',
+        type: 'shortstring',
+      },
+      {
+        name: 'version',
+        type: 'shortstring',
+      },
+    ],
+  },
+  primaryType: 'PersonalMessage',
+  domain: {
+    name: 'Lombard Staked Bitcoin',
+    version: '1.0.0',
+    revision: TypedDataRevision.ACTIVE,
+    chainId,
+  },
+  message: {
+    message: message,
+  },
+});