create-sbc-app 0.1.5 → 0.3.0

package/templates/react-para/src/utils/permit.ts.template

@@ -0,0 +1,217 @@
+import { hexToBytes, bytesToHex } from 'viem/utils';
+import { hashTypedData, recoverAddress } from 'viem';
+
+export type PermitTypedData = {
+  domain: {
+    name: string;
+    version: string;
+    chainId: bigint;
+    verifyingContract: `0x${string}`;
+  };
+  types: {
+    EIP712Domain: Array<{ name: string; type: string }>;
+    Permit: Array<{ name: string; type: string }>;
+  };
+  message: {
+    owner: `0x${string}`;
+    spender: `0x${string}`;
+    value: bigint;
+    nonce: bigint;
+    deadline: bigint;
+  };
+  primaryType: 'Permit';
+};
+
+export function buildPermitTypedData(params: {
+  tokenName: string;
+  chainId: number;
+  tokenAddress: `0x${string}`;
+  owner: `0x${string}`;
+  spender: `0x${string}`;
+  value: bigint;
+  nonce: bigint;
+  deadline: bigint;
+}): PermitTypedData {
+  const { tokenName, chainId, tokenAddress, owner, spender, value, nonce, deadline } = params;
+  return {
+    domain: {
+      name: tokenName,
+      version: '1',
+      chainId: BigInt(chainId),
+      verifyingContract: tokenAddress,
+    },
+    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 },
+  } as const;
+}
+
+export function hashPermitTypedData(typed: PermitTypedData): `0x${string}` {
+  return hashTypedData({
+    domain: typed.domain,
+    types: typed.types,
+    primaryType: typed.primaryType,
+    message: typed.message,
+  } as any);
+}
+
+export function hex32ToBase64(hex: `0x${string}`): string {
+  const bytes = hexToBytes(hex);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  return btoa(binary);
+}
+
+export function base64ToBytes(b64: string): Uint8Array {
+  const binary = atob(b64);
+  const len = binary.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+function isHexStringLike(s: string): boolean {
+  return /^[0-9a-fA-F]+$/.test(s);
+}
+
+export function normalizeSignatureToRSV(sig: string | { signatureBase64?: string; signature?: string }): {
+  r: `0x${string}`;
+  s: `0x${string}`;
+  v: number;
+} {
+  let sigBytes: Uint8Array;
+  if (typeof sig === 'string') {
+    const trimmed = sig.trim();
+    if (trimmed.startsWith('0x')) {
+      sigBytes = hexToBytes(trimmed as `0x${string}`);
+    } else if (isHexStringLike(trimmed) && (trimmed.length === 128 || trimmed.length === 130)) {
+      sigBytes = hexToBytes(('0x' + trimmed) as `0x${string}`);
+    } else {
+      const b = base64ToBytes(trimmed);
+      const asString = Array.from(b).every((c) => {
+        const ch = String.fromCharCode(c);
+        return /[0-9a-fA-Fx]/.test(ch);
+      })
+        ? String.fromCharCode(...b)
+        : null;
+      if (asString && (asString.startsWith('0x') || isHexStringLike(asString))) {
+        const hexStr = asString.startsWith('0x') ? asString : '0x' + asString;
+        sigBytes = hexToBytes(hexStr as `0x${string}`);
+      } else {
+        sigBytes = b;
+      }
+    }
+  } else if (sig?.signatureBase64) {
+    const b = base64ToBytes(sig.signatureBase64);
+    const isAsciiHex = Array.from(b).every((c) => /[0-9a-fA-Fx]/.test(String.fromCharCode(c)));
+    if (isAsciiHex) {
+      const s = String.fromCharCode(...b);
+      const hexStr = s.startsWith('0x') ? s : '0x' + s;
+      sigBytes = hexToBytes(hexStr as `0x${string}`);
+    } else {
+      sigBytes = b;
+    }
+  } else if (sig?.signature) {
+    const s = sig.signature as string;
+    if (s.startsWith('0x') || isHexStringLike(s)) {
+      const hexStr = s.startsWith('0x') ? s : '0x' + s;
+      sigBytes = hexToBytes(hexStr as `0x${string}`);
+    } else {
+      const b = base64ToBytes(s);
+      const isAsciiHex = Array.from(b).every((c) => /[0-9a-fA-Fx]/.test(String.fromCharCode(c)));
+      if (isAsciiHex) {
+        const txt = String.fromCharCode(...b);
+        const hexStr = txt.startsWith('0x') ? txt : '0x' + txt;
+        sigBytes = hexToBytes(hexStr as `0x${string}`);
+      } else {
+        sigBytes = b;
+      }
+    }
+  } else {
+    throw new Error('Unsupported signature format from Para signMessage');
+  }
+
+  if (sigBytes.length === 65) {
+    const r = bytesToHex(sigBytes.slice(0, 32)) as `0x${string}`;
+    const s = bytesToHex(sigBytes.slice(32, 64)) as `0x${string}`;
+    let v = sigBytes[64];
+    if (v < 27) v += 27;
+    return { r, s, v };
+  }
+
+  if (sigBytes.length === 64) {
+    const rBytes = sigBytes.slice(0, 32);
+    const yParityAndS = sigBytes.slice(32, 64);
+    const yParity = (yParityAndS[0] & 0x80) ? 1 : 0;
+    const sBytes = new Uint8Array(yParityAndS);
+    sBytes[0] &= 0x7f;
+    const r = bytesToHex(rBytes) as `0x${string}`;
+    const s = bytesToHex(sBytes) as `0x${string}`;
+    const v = 27 + yParity;
+    return { r, s, v };
+  }
+
+  if (sigBytes[0] === 0x30) {
+    let offset = 2;
+    if (sigBytes[1] & 0x80) {
+      const lenOfLen = sigBytes[1] & 0x7f;
+      offset = 2 + lenOfLen;
+    }
+    if (sigBytes[offset] !== 0x02) throw new Error('Invalid DER signature (missing r)');
+    const rLen = sigBytes[offset + 1];
+    const rStart = offset + 2;
+    const rEnd = rStart + rLen;
+    const rRaw = sigBytes.slice(rStart, rEnd);
+    offset = rEnd;
+    if (sigBytes[offset] !== 0x02) throw new Error('Invalid DER signature (missing s)');
+    const sLen = sigBytes[offset + 1];
+    const sStart = offset + 2;
+    const sEnd = sStart + sLen;
+    const sRaw = sigBytes.slice(sStart, sEnd);
+    const r = bytesToHex(leftPad32(rRaw)) as `0x${string}`;
+    const s = bytesToHex(leftPad32(sRaw)) as `0x${string}`;
+    return { r, s, v: 0 };
+  }
+
+  throw new Error(`Unexpected signature length: ${sigBytes.length}`);
+}
+
+function leftPad32(src: Uint8Array): Uint8Array {
+  if (src.length === 32) return src;
+  const out = new Uint8Array(32);
+  out.set(src, 32 - src.length);
+  return out;
+}
+
+export async function deriveVForRS(params: {
+  digest: `0x${string}`;
+  r: `0x${string}`;
+  s: `0x${string}`;
+  owner: `0x${string}`;
+}): Promise<number> {
+  const { digest, r, s, owner } = params;
+  for (const v of [27n, 28n]) {
+    try {
+      const addr = await recoverAddress({ hash: digest, signature: { r, s, v } });
+      if (addr.toLowerCase() === owner.toLowerCase()) return Number(v);
+    } catch {}
+  }
+  throw new Error('Failed to derive v that recovers owner');
+}
+
+
+

package/templates/react-para/tailwind.config.js.template

@@ -0,0 +1,13 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+
+

package/templates/react-para/tsconfig.json.template

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true
+  },
+  "include": ["src"]
+}
+
+

package/templates/react-para/vite.config.ts.template

@@ -0,0 +1,73 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import { nodePolyfills } from 'vite-plugin-node-polyfills'
+
+// Strip sourceMappingURL comments from problematic vendor files to silence missing sourcemap warnings
+function stripVendorSourcemaps() {
+  const vendorRe = /node_modules\/(?:@walletconnect|@cosmjs|@cosmsnap)\//;
+  const mapLine = /\/\/#\s*sourceMappingURL=.*$/gm;
+  return {
+    name: 'strip-vendor-sourcemaps',
+    enforce: 'post' as const,
+    transform(code: string, id: string) {
+      if (!vendorRe.test(id)) return null;
+      if (!mapLine.test(code)) return null;
+      const cleaned = code.replace(mapLine, '');
+      return { code: cleaned, map: null };
+    }
+  }
+}
+
+// Esbuild plugin variant for optimizeDeps stage
+function esbuildStripVendorSourcemaps() {
+  const vendorRe = /node_modules\/(?:@walletconnect|@cosmjs|@cosmsnap)\//;
+  const mapLine = /\/\/#\s*sourceMappingURL=.*$/gm;
+  return {
+    name: 'esbuild-strip-vendor-sourcemaps',
+    setup(build: any) {
+      build.onLoad({ filter: /\.(mjs|cjs|js)$/ }, async (args: any) => {
+        if (!vendorRe.test(args.path)) return;
+        const fs = await import('fs/promises');
+        try {
+          const code = await fs.readFile(args.path, 'utf8');
+          if (!mapLine.test(code)) return;
+          const cleaned = code.replace(mapLine, '');
+          return { contents: cleaned, loader: 'js' };
+        } catch {
+          return;
+        }
+      });
+    }
+  }
+}
+
+export default defineConfig({
+  plugins: [react(), nodePolyfills(), stripVendorSourcemaps()],
+  define: { global: 'globalThis' },
+  server: { port: 3000 },
+  optimizeDeps: {
+    exclude: [
+      '@getpara/cosmos-wallet-connectors',
+      '@getpara/solana-wallet-connectors',
+      '@cosmjs/*',
+      '@cosmsnap/*'
+    ],
+    esbuildOptions: {
+      sourcemap: false,
+      plugins: [esbuildStripVendorSourcemaps()]
+    }
+  },
+  build: {
+    sourcemap: false,
+    rollupOptions: {
+      external: [
+        '@getpara/cosmos-wallet-connectors',
+        '@getpara/solana-wallet-connectors',
+        /@cosmjs\//,
+        /@cosmsnap\//
+      ]
+    }
+  }
+})
+
+