Covenants integration infrastructure

web-v2/eslint.config.js

@@ -41,6 +41,7 @@ export default defineConfig([
       },
     },
     settings: {
+      'import/core-modules': ['virtual:simplicity-sources'],
       'import/resolver': {
         typescript: {},
         node: {

web-v2/plugins/lwkWasmPlugin.ts

@@ -0,0 +1,36 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import type { Plugin } from 'vite'
+
+interface LwkWasmPluginOptions {
+  wasmPath: string
+}
+
+export function lwkWasmPlugin(options: LwkWasmPluginOptions): Plugin {
+  return {
+    name: 'lwk-wasm',
+
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (!req.url) {
+          return next()
+        }
+
+        if (!req.url.endsWith('lwk_wasm_bg.wasm')) {
+          return next()
+        }
+
+        const wasmFile = path.resolve(options.wasmPath)
+
+        if (!fs.existsSync(wasmFile)) {
+          return next()
+        }
+
+        res.setHeader('Content-Type', 'application/wasm')
+
+        fs.createReadStream(wasmFile).pipe(res)
+      })
+    },
+  }
+}

web-v2/plugins/simplicitySourcesPlugin.ts

@@ -0,0 +1,72 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import type { Plugin, ResolvedConfig } from 'vite'
+
+// Internal Vite virtual module id.
+// We dynamically generate this module from raw .simf covenant sources
+// so the frontend can import them like a normal ES module.
+const SIMPLICITY_SOURCES_VIRTUAL = '\0virtual:simplicity-sources'
+
+interface CovenantConfig {
+  covenants: Array<{
+    id: string
+    path: string
+  }>
+}
+
+interface SimplicitySourcesPluginOptions {
+  configPath: string
+}
+
+export function simplicitySourcesPlugin(options: SimplicitySourcesPluginOptions): Plugin {
+  let viteConfig: ResolvedConfig
+
+  return {
+    name: 'simplicity-sources',
+
+    configResolved(config) {
+      viteConfig = config
+    },
+
+    resolveId(id) {
+      if (id === 'virtual:simplicity-sources') {
+        return SIMPLICITY_SOURCES_VIRTUAL
+      }
+
+      return null
+    },
+
+    load(id) {
+      if (id !== SIMPLICITY_SOURCES_VIRTUAL) {
+        return null
+      }
+
+      const resolvedConfigPath = path.resolve(viteConfig.root, options.configPath)
+
+      if (!fs.existsSync(resolvedConfigPath)) {
+        throw new Error(`Simplicity config not found: ${resolvedConfigPath}`)
+      }
+
+      const rawConfig = fs.readFileSync(resolvedConfigPath, 'utf-8')
+
+      const config = JSON.parse(rawConfig) as CovenantConfig
+
+      const sources: Record<string, string> = {}
+
+      for (const covenant of config.covenants) {
+        const covenantPath = path.resolve(viteConfig.root, covenant.path)
+
+        if (!fs.existsSync(covenantPath)) {
+          throw new Error(`Simplicity covenant file not found: ${covenantPath}`)
+        }
+
+        sources[covenant.id] = fs.readFileSync(covenantPath, 'utf-8').trim()
+      }
+
+      return `
+        export const sources = ${JSON.stringify(sources)}
+      `
+    },
+  }
+}

web-v2/simplicity-covenants.config.json

@@ -0,0 +1,7 @@
+{
+  "covenants": [
+    { "id": "lending", "path": "../crates/contracts/simf/lending.simf" },
+    { "id": "asset_auth", "path": "../crates/contracts/simf/asset_auth.simf" },
+    { "id": "script_auth", "path": "../crates/contracts/simf/script_auth.simf" }
+  ]
+}

web-v2/src/lib/pset-builder/buildExplicitRecipientPset.ts

@@ -0,0 +1,27 @@
+import { Address, type Network, type OutPoint, type Pset, TxBuilder, type Wollet } from 'lwk_web'
+
+interface BuildExplicitRecipientPsetParams {
+  wollet: Wollet
+  network: Network
+  recipientAddress: string
+  outpoints: OutPoint[]
+  satoshi: bigint
+  feeRate?: number
+}
+
+export function buildExplicitRecipientPset({
+  wollet,
+  network,
+  recipientAddress,
+  outpoints,
+  satoshi,
+  feeRate = 1,
+}: BuildExplicitRecipientPsetParams): Pset {
+  const address = new Address(recipientAddress)
+
+  return new TxBuilder(network)
+    .feeRate(feeRate)
+    .setWalletUtxos(outpoints)
+    .addExplicitRecipient(address, satoshi, network.policyAsset())
+    .finish(wollet)
+}

web-v2/src/lib/pset-builder/buildExternalExplicitRecipientPset.ts

@@ -0,0 +1,41 @@
+import {
+  Address,
+  type ExternalUtxo,
+  type Network,
+  type OutPoint,
+  type Pset,
+  TxBuilder,
+  type Wollet,
+} from 'lwk_web'
+
+interface BuildExternalExplicitRecipientPsetParams {
+  wollet: Wollet
+  network: Network
+  recipientAddress: string
+  outpoints: OutPoint[]
+  externalUtxos: ExternalUtxo[]
+  satoshi: bigint
+  feeRate?: number
+}
+
+export function buildExternalExplicitRecipientPset({
+  wollet,
+  network,
+  recipientAddress,
+  outpoints,
+  externalUtxos,
+  satoshi,
+  feeRate = 1,
+}: BuildExternalExplicitRecipientPsetParams): Pset {
+  const address = new Address(recipientAddress)
+  void externalUtxos
+
+  return (
+    new TxBuilder(network)
+      .feeRate(feeRate)
+      .setWalletUtxos(outpoints)
+      // .addExternalUtxos(externalUtxos) // TODO: expose TxBuilder.addExternalUtxos() in lwk_web.
+      .addExplicitRecipient(address, satoshi, network.policyAsset())
+      .finish(wollet)
+  )
+}

web-v2/src/lib/pset-builder/index.ts

@@ -0,0 +1,2 @@
+export { buildExplicitRecipientPset } from './buildExplicitRecipientPset'
+export { buildExternalExplicitRecipientPset } from './buildExternalExplicitRecipientPset'

web-v2/src/lib/wallet-core/connector/jade.ts

@@ -1,6 +1,11 @@
-import type { Jade, Network, Pset, Wollet, WolletDescriptor } from 'lwk_web'
-
-import type { Lwk } from '@/lwk'
+import {
+  Jade,
+  type Network,
+  type Pset,
+  Singlesig,
+  type Wollet,
+  type WolletDescriptor,
+} from 'lwk_web'
 
 import type { ConnectionStatus, JadeVersionInfo, WalletType } from '../types'
 import type { WalletConnector } from './types'
@@ -17,17 +22,14 @@ export class JadeConnector implements WalletConnector {
   private busy = false
   private _id: string | null = null
 
-  constructor(
-    private readonly lwk: Lwk,
-    private readonly lwkNetwork: Network,
-  ) {}
+  constructor(private readonly lwkNetwork: Network) {}
 
   async connect(): Promise<void> {
     if (this.jade !== null) return
     // HACK: The TS bindings declare this as a sync constructor, but wasm-bindgen
     // generates an async constructor under the hood that returns a Promise.
     // `await new this.lwk.Jade(...)` is intentional — not a mistake.
-    this.jade = await new this.lwk.Jade(this.lwkNetwork, true)
+    this.jade = await new Jade(this.lwkNetwork, true)
   }
 
   disconnect(): void {
@@ -91,7 +93,7 @@ export class JadeConnector implements WalletConnector {
     const addrResult = wollet.address()
     const index = addrResult.index()
     const path = wollet.addressFullPath(index)
-    const singlesig = this.lwk.Singlesig.from(variant)
+    const singlesig = Singlesig.from(variant)
     return await this.jade.getReceiveAddressSingle(singlesig, path)
   }
 

web-v2/src/lib/wallet-core/connector/seed.ts

@@ -1,6 +1,12 @@
-import type { Network, Pset, Signer, WolletDescriptor } from 'lwk_web'
-
-import type { Lwk } from '@/lwk'
+import {
+  Mnemonic,
+  type Network,
+  type Pset,
+  Signer,
+  simplicityDeriveXonlyPubkey,
+  type WolletDescriptor,
+  XOnlyPublicKey,
+} from 'lwk_web'
 
 import type { ConnectionStatus, WalletType } from '../types'
 import type { WalletConnector } from './types'
@@ -19,7 +25,6 @@ export class SeedConnector implements WalletConnector {
   private _id: string | null = null
 
   constructor(
-    private readonly lwk: Lwk,
     private readonly lwkNetwork: Network,
     private readonly mnemonicStr: string,
   ) {
@@ -28,8 +33,8 @@ export class SeedConnector implements WalletConnector {
 
   async connect(): Promise<void> {
     if (this.signer !== null) return
-    const mnemonic = new this.lwk.Mnemonic(this.mnemonicStr)
-    this.signer = new this.lwk.Signer(mnemonic, this.lwkNetwork)
+    const mnemonic = new Mnemonic(this.mnemonicStr)
+    this.signer = new Signer(mnemonic, this.lwkNetwork)
     this._id = crypto.randomUUID()
   }
 
@@ -61,11 +66,11 @@ export class SeedConnector implements WalletConnector {
     return this.signer.sign(pset)
   }
 
-  async getXOnlyPublicKey(): Promise<string> {
+  async getXOnlyPublicKey(): Promise<XOnlyPublicKey> {
     if (!this.signer) throw new Error('SeedConnector: not connected')
     //github.com/BlockstreamResearch/smplx/blob/1945d11b47fff8838c3e99c210133519a9522324/crates/sdk/src/signer/core.rs#L621C1-L628C2
     const path = this.lwkNetwork.isMainnet() ? 'm/84h/1776h/0h/0/1' : 'm/84h/1h/0h/0/1'
-    return this.lwk.simplicityDeriveXonlyPubkey(this.signer, path).toString()
+    return simplicityDeriveXonlyPubkey(this.signer, path)
   }
 
   async getConnectionStatus(): Promise<ConnectionStatus> {

web-v2/src/lib/wallet-core/connector/types.ts

@@ -1,4 +1,4 @@
-import type { Pset, Wollet, WolletDescriptor } from 'lwk_web'
+import type { Pset, Wollet, WolletDescriptor, XOnlyPublicKey } from 'lwk_web'
 
 import type { ConnectionStatus, WalletType } from '../types'
 
@@ -10,6 +10,6 @@ export interface WalletConnector {
   signPset(pset: Pset): Promise<Pset>
   isConnected: boolean
   getConnectionStatus(): Promise<ConnectionStatus>
-  getXOnlyPublicKey?(): Promise<string>
+  getXOnlyPublicKey?(): Promise<XOnlyPublicKey>
   getVerifiedReceiveAddress?(variant: WalletType, wollet: Wollet): Promise<string>
 }

web-v2/src/lwk/index.ts

@@ -1,10 +1,4 @@
-import type {
-  EsploraClient,
-  Network,
-  SimplicityArguments,
-  Transaction,
-  XOnlyPublicKey,
-} from 'lwk_web'
+import { EsploraClient, Network, type Transaction } from 'lwk_web'
 
 import { env, type NetworkName } from '@/constants/env'
 
@@ -20,41 +14,27 @@ export async function getLwk(): Promise<Lwk> {
   return lwk
 }
 
-export function createLwkNetwork(network: NetworkName, lwk: Lwk): Network {
+export function createLwkNetwork(network: NetworkName): Network {
   switch (network) {
     case 'liquid':
-      return lwk.Network.mainnet()
+      return Network.mainnet()
     case 'liquidtestnet':
-      return lwk.Network.testnet()
+      return Network.testnet()
     case 'regtest':
-      return lwk.Network.regtestDefault()
+      return Network.regtestDefault()
   }
 }
 
 export interface PsetWithExtractTx {
   extractTx(): Transaction
 }
 
-export interface CreateP2trAddressParams {
-  source: string
-  args: SimplicityArguments
-  internalKey: XOnlyPublicKey
-  network: NetworkName
-}
-
-export function createP2trAddress(lwk: Lwk, params: CreateP2trAddressParams): string {
-  const program = lwk.SimplicityProgram.load(params.source, params.args)
-  const net = createLwkNetwork(params.network, lwk)
-  const address = program.createP2trAddress(params.internalKey, net)
-  return address.toString()
-}
-
 /**
  * Creates an EsploraClient configured for waterfalls + utxoOnly scanning.
  * Waterfalls provides fast indexed encrypted UTXO discovery vs slow sequential HD scan.
  */
-export function createEsploraClient(lwk: Lwk, lwkNetwork: Network): EsploraClient {
-  const client = new lwk.EsploraClient(
+export function createEsploraClient(lwkNetwork: Network): EsploraClient {
+  const client = new EsploraClient(
     lwkNetwork,
     `${env.VITE_WATERFALLS_URL}/api`,
     true, // waterfalls