create-openfort 0.1.10 → 1.0.0

package/template/openfort-templates/solana-headless/src/lib/solana/kora.ts

@@ -0,0 +1,137 @@
+import type { OpenfortEmbeddedSolanaWalletProvider } from '@openfort/react/solana'
+import {
+  type Address,
+  appendTransactionMessageInstructions,
+  type Blockhash,
+  createNoopSigner,
+  createTransactionMessage,
+  getBase64EncodedWireTransaction,
+  type Instruction,
+  type MicroLamports,
+  partiallySignTransactionMessageWithSigners,
+  type SignatureBytes,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
+} from '@solana/kit'
+import { KoraClient } from '@solana/kora'
+import {
+  updateOrAppendSetComputeUnitLimitInstruction,
+  updateOrAppendSetComputeUnitPriceInstruction,
+} from '@solana-program/compute-budget'
+import { Base58 } from 'ox'
+
+const COMPUTE_UNIT_LIMIT = 200_000
+const COMPUTE_UNIT_PRICE = 50_000n as MicroLamports
+
+interface KoraConfig {
+  rpcUrl: string
+  apiKey: string
+}
+
+interface SendGaslessTransactionParams {
+  from: Address
+  to: Address
+  amountInSol: number
+  provider: OpenfortEmbeddedSolanaWalletProvider
+  koraConfig: KoraConfig
+}
+
+interface GaslessTransactionResult {
+  signature: string
+}
+
+/** Validate that the signature is a 64-byte Ed25519 signature */
+function validateEd25519Signature(raw: Uint8Array): Uint8Array {
+  if (raw.length !== 64) {
+    throw new Error(`Invalid Ed25519 signature: expected 64 bytes, got ${raw.length}`)
+  }
+  return raw
+}
+
+function buildTransactionMessage(
+  feePayer: ReturnType<typeof createNoopSigner>,
+  blockhash: string,
+  instructions: Instruction[]
+) {
+  const msg = createTransactionMessage({ version: 0 })
+  const withPayer = setTransactionMessageFeePayerSigner(feePayer, msg)
+  const withLifetime = setTransactionMessageLifetimeUsingBlockhash(
+    { blockhash: blockhash as Blockhash, lastValidBlockHeight: 0n },
+    withPayer
+  )
+  const withPrice = updateOrAppendSetComputeUnitPriceInstruction(COMPUTE_UNIT_PRICE, withLifetime)
+  const withLimit = updateOrAppendSetComputeUnitLimitInstruction(COMPUTE_UNIT_LIMIT, withPrice)
+  return appendTransactionMessageInstructions(instructions, withLimit)
+}
+
+export async function sendGaslessSolTransaction({
+  from,
+  to,
+  amountInSol,
+  provider,
+  koraConfig,
+}: SendGaslessTransactionParams): Promise<GaslessTransactionResult> {
+  const client = new KoraClient({
+    rpcUrl: koraConfig.rpcUrl,
+    apiKey: koraConfig.apiKey,
+  })
+
+  // Step 1: Get Kora's signer address
+  const { signer_address } = await client.getPayerSigner()
+  const koraNoopSigner = createNoopSigner(signer_address as Address)
+
+  // Step 2: Create transfer instruction via Kora
+  const transferLamports = Math.floor(amountInSol * 1_000_000_000)
+  const transferSol = await client.transferTransaction({
+    amount: transferLamports,
+    token: '11111111111111111111111111111111',
+    source: from,
+    destination: to,
+    signer_key: signer_address,
+  })
+
+  // Step 3: Build transaction with Kora as fee payer
+  const { blockhash } = await client.getBlockhash()
+  const transaction = buildTransactionMessage(koraNoopSigner, blockhash, transferSol.instructions)
+
+  // Step 4: Partially sign (noop for Kora placeholder), then sign with Openfort
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const partiallySignedTx = await partiallySignTransactionMessageWithSigners(transaction as any)
+
+  const result = await provider.signTransaction(new Uint8Array(partiallySignedTx.messageBytes))
+  const signatureBytes = validateEd25519Signature(Base58.toBytes(result.signature))
+
+  const userSignedTx = {
+    ...partiallySignedTx,
+    signatures: {
+      ...partiallySignedTx.signatures,
+      [from]: signatureBytes as SignatureBytes,
+    },
+  }
+  const userSignedWire = getBase64EncodedWireTransaction(userSignedTx)
+
+  // Step 5: Send to Kora for co-signing and submission to Solana
+  const response = await client.signAndSendTransaction({
+    transaction: userSignedWire,
+    signer_key: signer_address,
+  })
+
+  // Extract signature: Kora may return it directly or in signed_transaction wire format
+  let txSignature = (response as unknown as Record<string, unknown>).signature as string | undefined
+  if (!txSignature) {
+    const signedTxB64 = (response as unknown as Record<string, unknown>).signed_transaction as string | undefined
+    if (signedTxB64) {
+      const wireBytes = Uint8Array.from(atob(signedTxB64), (c) => c.charCodeAt(0))
+      // Wire format: [num_signatures (1 byte), ...signatures (64 bytes each), ...]
+      // First signature (bytes 1..65) is the tx signature
+      const firstSig = wireBytes.slice(1, 65)
+      txSignature = Base58.fromBytes(firstSig)
+    }
+  }
+
+  if (!txSignature) {
+    throw new Error('Failed to extract transaction signature from Kora response')
+  }
+
+  return { signature: txSignature }
+}

package/template/openfort-templates/solana-headless/src/lib/solana/transaction.ts

@@ -0,0 +1,146 @@
+import type { OpenfortEmbeddedSolanaWalletProvider } from '@openfort/react/solana'
+import {
+  type Address,
+  appendTransactionMessageInstruction,
+  assertIsTransactionWithBlockhashLifetime,
+  createSolanaRpc,
+  createSolanaRpcSubscriptions,
+  createTransactionMessage,
+  lamports,
+  pipe,
+  type SignatureBytes,
+  type SignatureDictionary,
+  sendAndConfirmTransactionFactory,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  signTransactionMessageWithSigners,
+  type TransactionSigner,
+} from '@solana/kit'
+import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction } from '@solana-program/compute-budget'
+import { getTransferSolInstruction } from '@solana-program/system'
+import { Base58 } from 'ox'
+
+const COMPUTE_UNIT_LIMIT = 200_000
+const COMPUTE_UNIT_PRICE = 50_000n // microlamports
+
+interface SendTransactionParams {
+  from: Address
+  to: Address
+  amountInSol: number
+  provider: OpenfortEmbeddedSolanaWalletProvider
+  rpcUrl?: string
+}
+
+interface TransactionResult {
+  signature: string
+}
+
+/** Convert a decimal amount to the smallest unit (e.g. SOL to lamports) without floating-point loss */
+function toSmallestUnit(amount: number, decimals: number): bigint {
+  const str = amount.toString()
+  const [whole, frac = ''] = str.split('.')
+  const padded = (frac + '0'.repeat(decimals)).slice(0, decimals)
+  return BigInt(whole + padded)
+}
+
+/** Validate that the signature is a 64-byte Ed25519 signature */
+function validateEd25519Signature(raw: Uint8Array): Uint8Array {
+  if (raw.length !== 64) {
+    throw new Error(`Invalid Ed25519 signature: expected 64 bytes, got ${raw.length}`)
+  }
+  return raw
+}
+
+/** Extract the fee payer's signature from the signed transaction */
+function getTransactionSignature(signatures: Record<string, SignatureBytes | null>, feePayer: Address): string {
+  const sig = signatures[feePayer]
+  if (!sig) {
+    throw new Error(`Fee payer signature not found for address: ${feePayer}`)
+  }
+  return Base58.fromBytes(sig)
+}
+
+function deriveWssUrl(rpcUrl: string): string {
+  try {
+    const parsed = new URL(rpcUrl)
+    const hostname = parsed.hostname
+    if (hostname === 'openfort.io' || hostname.endsWith('.openfort.io')) {
+      return 'wss://api.devnet.solana.com'
+    }
+  } catch {
+    // fall through
+  }
+  return rpcUrl.replace(/^https?:\/\//, 'wss://')
+}
+
+function createProviderSigner(
+  signerAddress: Address,
+  provider: OpenfortEmbeddedSolanaWalletProvider
+): TransactionSigner {
+  return {
+    address: signerAddress,
+    signTransactions: async (transactions): Promise<readonly SignatureDictionary[]> => {
+      return Promise.all(
+        transactions.map(async (transaction) => {
+          const result = await provider.signTransaction({
+            messageBytes: new Uint8Array(transaction.messageBytes),
+          })
+          const signatureBytes = validateEd25519Signature(Base58.toBytes(result.signature))
+          return Object.freeze({
+            [signerAddress]: signatureBytes as SignatureBytes,
+          })
+        })
+      )
+    },
+  }
+}
+
+export async function sendSolTransaction({
+  from,
+  to,
+  amountInSol,
+  provider,
+  rpcUrl,
+}: SendTransactionParams): Promise<TransactionResult> {
+  const httpUrl = rpcUrl ?? 'https://api.devnet.solana.com'
+  const rpc = createSolanaRpc(httpUrl)
+  const rpcSubscriptions = createSolanaRpcSubscriptions(deriveWssUrl(httpUrl))
+
+  const signer = createProviderSigner(from, provider)
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send()
+
+  const transactionMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayer(from, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: COMPUTE_UNIT_LIMIT }), tx),
+    (tx) =>
+      appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: COMPUTE_UNIT_PRICE }), tx),
+    (tx) =>
+      appendTransactionMessageInstruction(
+        getTransferSolInstruction({
+          source: signer,
+          destination: to,
+          amount: lamports(toSmallestUnit(amountInSol, 9)),
+        }),
+        tx
+      )
+  )
+
+  const signedTransaction = await signTransactionMessageWithSigners(transactionMessage)
+  assertIsTransactionWithBlockhashLifetime(signedTransaction)
+
+  const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })
+  const abortController = new AbortController()
+  const timeout = setTimeout(() => abortController.abort(), 60_000)
+  try {
+    await sendAndConfirmTransaction(signedTransaction, {
+      commitment: 'confirmed',
+      abortSignal: abortController.signal,
+    })
+  } finally {
+    clearTimeout(timeout)
+  }
+
+  return { signature: getTransactionSignature(signedTransaction.signatures, from) }
+}

package/template/openfort-templates/solana-headless/src/lib/solana/transactionHistory.ts

@@ -0,0 +1,39 @@
+interface TransactionHistoryItem {
+  signature: string
+  slot: number
+  blockTime: number | null
+  err: unknown | null
+  memo: string | null
+}
+
+const DEFAULT_RPC = 'https://api.devnet.solana.com'
+
+/**
+ * Fetches tx history via raw JSON-RPC (avoids @solana/kit transport issues in browser).
+ */
+export async function getTransactionHistory(
+  address: string,
+  limit = 10,
+  rpcUrl?: string
+): Promise<TransactionHistoryItem[]> {
+  const rpc = rpcUrl ?? DEFAULT_RPC
+  const res = await fetch(rpc, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'getSignaturesForAddress',
+      params: [address, { limit, commitment: 'confirmed' }],
+    }),
+  })
+  const data = await res.json()
+  if (!data.result) return []
+  return data.result.map((sig: Record<string, unknown>) => ({
+    signature: sig.signature as string,
+    slot: sig.slot as number,
+    blockTime: (sig.blockTime as number) ?? null,
+    err: sig.err ?? null,
+    memo: (sig.memo as string) ?? null,
+  }))
+}

package/template/openfort-templates/solana-headless/src/main.tsx

@@ -0,0 +1,13 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import App from './App.tsx'
+import { Providers } from './components/providers.tsx'
+import './index.css'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <Providers>
+      <App />
+    </Providers>
+  </StrictMode>,
+)

package/template/openfort-templates/solana-headless/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/template/openfort-templates/solana-headless/tsconfig.app.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

package/template/openfort-templates/solana-headless/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

package/template/openfort-templates/solana-headless/tsconfig.node.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/template/openfort-templates/solana-headless/vite.config.ts

@@ -0,0 +1,8 @@
+import tailwindcss from '@tailwindcss/vite'
+import react from '@vitejs/plugin-react'
+import { defineConfig } from 'vite'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+})