tapimo 0.1.0 → 0.2.0

package/src/handlers/internal/multisig.test.ts

@@ -1,9 +1,13 @@
 import { Address, Hex, P256 } from 'ox'
 import { MultisigConfig, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
 import { createClient, custom } from 'viem'
+import { prepareTransactionRequest, sendTransactionSync, signTransaction } from 'viem/actions'
 import { Account, Transaction } from 'viem/tempo'
 import { tempoDevnet } from 'viem/tempo/chains'
 
+import * as Relay from '../../../test/Relay.js'
+import * as Runtime from '../../../test/runtime.js'
+import * as StateStore from '../../internal/Store.js'
 import * as Multisig from './multisig.js'
 
 const privateKey_1 = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'
@@ -245,12 +249,12 @@ describe('config resolution', () => {
     expect({
       hash,
       init: transaction_submitted.signature.init
-        ? MultisigConfig.toId(transaction_submitted.signature.init)
+        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
         : undefined,
     }).toMatchInlineSnapshot(`
       {
         "hash": "${hash}",
-        "init": "${MultisigConfig.toId(account.config)}",
+        "init": "${account.address.toLowerCase()}",
       }
     `)
   })
@@ -311,12 +315,12 @@ describe('config resolution', () => {
     expect({
       hash,
       init: transaction_submitted.signature.init
-        ? MultisigConfig.toId(transaction_submitted.signature.init)
+        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
         : undefined,
     }).toMatchInlineSnapshot(`
       {
         "hash": "${hash}",
-        "init": "${MultisigConfig.toId(account.config)}",
+        "init": "${account.address.toLowerCase()}",
       }
     `)
   })
@@ -376,12 +380,12 @@ describe('config resolution', () => {
     expect({
       hash,
       init: transaction_submitted.signature.init
-        ? MultisigConfig.toId(transaction_submitted.signature.init)
+        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
         : undefined,
     }).toMatchInlineSnapshot(`
       {
         "hash": "${hash}",
-        "init": "${MultisigConfig.toId(account.config)}",
+        "init": "${account.address.toLowerCase()}",
       }
     `)
   })
@@ -474,12 +478,12 @@ describe('config resolution', () => {
       signature: SignatureEnvelope.Multisig
     }
     expect({
+      account: transaction_submitted.signature.account,
       hash,
       init: transaction_submitted.signature.init,
-      genesisConfigId: transaction_submitted.signature.genesisConfigId,
     }).toMatchInlineSnapshot(`
       {
-        "genesisConfigId": "${MultisigConfig.toId(account.config)}",
+        "account": "${account.address.toLowerCase()}",
         "hash": "${hash}",
         "init": undefined,
       }
@@ -566,6 +570,7 @@ describe('handleRawTransaction with sponsor', () => {
       signatures: [signature_2],
     } as never)
     const broadcasted: string[] = []
+    const sponsored: unknown[] = []
 
     await Multisig.handleRawTransaction({
       getClient: (() => undefined) as never,
@@ -593,6 +598,10 @@ describe('handleRawTransaction with sponsor', () => {
       request: { params: [second] },
       sponsor: {
         account: feePayer as never,
+        onSponsored: (event) => {
+          sponsored.push(event)
+          expect(broadcasted).toHaveLength(0)
+        },
         resolveFeeToken: () => feeToken,
       },
       store,
@@ -608,6 +617,7 @@ describe('handleRawTransaction with sponsor', () => {
       feeToken: (transaction_broadcasted['feeToken'] as string).toLowerCase(),
       hash,
       init: Boolean(signature.init),
+      sponsored: sponsored.length,
       signature: signature.type,
     }).toMatchInlineSnapshot(`
       {
@@ -616,6 +626,7 @@ describe('handleRawTransaction with sponsor', () => {
         "hash": "${hash}",
         "init": true,
         "signature": "multisig",
+        "sponsored": 1,
       }
     `)
   })
@@ -706,13 +717,77 @@ describe('handleRawTransaction with sponsor', () => {
   })
 })
 
+describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG === 'sha-8968664')(
+  'e2e',
+  () => {
+    const owner_1 = Relay.accounts[1]!
+    const owner_2 = Relay.accounts[2]!
+    const feePayer = Relay.accounts[0]!
+    const sponsorFeeToken = Relay.addresses.pathUsd
+    const store = StateStore.memory()
+    let client: ReturnType<typeof Relay.getClient>
+    let server: Relay.Server
+
+    beforeAll(async () => {
+      server = await Relay.createServer(
+        (
+          await Relay.relay({
+            feePayer: {
+              account: feePayer,
+              feeToken: sponsorFeeToken,
+            },
+            multisig: { store },
+          })
+        ).listener,
+      )
+      client = Relay.getClient({ url: server.url })
+    })
+
+    afterAll(() => {
+      server.close()
+    })
+
+    test('behavior: sponsors bootstrap multisig', async () => {
+      const account = Account.fromMultisig({
+        threshold: 2,
+        owners: [
+          { owner: owner_1.address, weight: 1 },
+          { owner: owner_2.address, weight: 1 },
+        ],
+      })
+      const transaction = await prepareTransactionRequest(client, {
+        account,
+        feePayer: true,
+        to: account.address,
+        value: 0n,
+      })
+      const signatures = await Promise.all(
+        [owner_1, owner_2].map((owner) =>
+          signTransaction(client, { ...transaction, account: owner }),
+        ),
+      )
+      const receipt = await sendTransactionSync(client, {
+        ...transaction,
+        account,
+        signatures,
+      })
+
+      expect(receipt).toMatchObject({
+        feePayer: feePayer.address.toLowerCase(),
+        feeToken: sponsorFeeToken.toLowerCase(),
+        from: account.address.toLowerCase(),
+        status: 'success',
+      })
+    })
+  },
+)
+
 function createOperation(): Multisig.Operation {
   const now = Date.now()
   return {
     account: '0x0000000000000000000000000000000000000001',
     chainId: tempoDevnet.id,
     createdAt: now,
-    genesisConfigId: `0x${'11'.repeat(32)}`,
     id: `0x${'22'.repeat(32)}`,
     payload: `0x${'33'.repeat(32)}`,
     signatures: [],
@@ -737,7 +812,6 @@ function withoutInit(serialized: `0x${string}`) {
   return TxEnvelopeTempo.serialize(TxEnvelopeTempo.from(unsigned as never), {
     signature: SignatureEnvelope.from({
       account: signature.account,
-      genesisConfigId: signature.genesisConfigId,
       signatures: signature.signatures,
     }),
   })

package/src/handlers/internal/multisig.ts

@@ -66,7 +66,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
   const config = await resolveValidatedConfig({
     account: input.account,
     chainId: input.chainId,
-    genesisConfigId: input.genesisConfigId,
     init: input.init,
     pending,
     resolveConfig,
@@ -78,7 +77,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
     })
   const initConfig = resolveInitConfig({
     config,
-    genesisConfigId: input.genesisConfigId,
     init: input.init,
     nonce: input.nonce,
     pending,
@@ -91,7 +89,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
     claimExpiresAt: pending?.claimExpiresAt,
     config,
     createdAt: pending?.createdAt ?? now,
-    genesisConfigId: input.genesisConfigId,
     id: input.id,
     init: pending?.init || !!initConfig,
     initConfig,
@@ -106,7 +103,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
   let approvals = getApprovals({
     account: input.account,
     config,
-    genesisConfigId: input.genesisConfigId,
     payload: input.payload,
     signatures: operation.signatures,
   })
@@ -121,7 +117,6 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
     approvals = getApprovals({
       account: operation.account,
       config,
-      genesisConfigId: operation.genesisConfigId,
       payload: operation.payload,
       signatures: operation.signatures,
     })
@@ -136,14 +131,12 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
   approvals = getApprovals({
     account: operation.account,
     config,
-    genesisConfigId: operation.genesisConfigId,
     payload: operation.payload,
     signatures: operation.signatures,
   })
   const client = getClient(operation.chainId)
   const final = await serializeFinal({
     account: operation.account,
-    genesisConfigId: operation.genesisConfigId,
     init: operation.initConfig ?? initConfig,
     signatures: approvals.signatures,
     transaction: input.transaction,
@@ -199,6 +192,7 @@ async function collect(options: collect.Options): Promise<collect.ReturnType> {
           : undefined,
         getClient,
         method: broadcastMethod,
+        onSponsored: sponsor.onSponsored,
         request: { params: [final] },
         sender: operation.account,
         validate: sponsor.validate,
@@ -295,7 +289,6 @@ export async function getStatus(options: getStatus.Options): Promise<Status | nu
   const config = await resolveValidatedConfig({
     account: operation.account,
     chainId: operation.chainId,
-    genesisConfigId: operation.genesisConfigId,
     pending: operation,
     resolveConfig: options.resolveConfig,
   })
@@ -303,7 +296,6 @@ export async function getStatus(options: getStatus.Options): Promise<Status | nu
     return {
       account: operation.account,
       chainId: operation.chainId,
-      genesisConfigId: operation.genesisConfigId,
       id: operation.id,
       signatures: operation.signatures.length,
       status: operation.status,
@@ -312,7 +304,6 @@ export async function getStatus(options: getStatus.Options): Promise<Status | nu
   const approvals = getApprovals({
     account: operation.account,
     config,
-    genesisConfigId: operation.genesisConfigId,
     payload: operation.payload,
     signatures: operation.signatures,
   })
@@ -339,7 +330,6 @@ export async function listStatuses(options: listStatuses.Options): Promise<reado
       const config = await resolveValidatedConfig({
         account: operation.account,
         chainId: operation.chainId,
-        genesisConfigId: operation.genesisConfigId,
         pending: operation,
         resolveConfig: options.resolveConfig,
       })
@@ -347,7 +337,6 @@ export async function listStatuses(options: listStatuses.Options): Promise<reado
         return {
           account: operation.account,
           chainId: operation.chainId,
-          genesisConfigId: operation.genesisConfigId,
           id: operation.id,
           signatures: operation.signatures.length,
           status: operation.status,
@@ -356,7 +345,6 @@ export async function listStatuses(options: listStatuses.Options): Promise<reado
       const approvals = getApprovals({
         account: operation.account,
         config,
-        genesisConfigId: operation.genesisConfigId,
         payload: operation.payload,
         signatures: operation.signatures,
       })
@@ -497,8 +485,6 @@ export type ResolveConfig = (request: {
   account: Address
   /** Transaction chain id. */
   chainId: number
-  /** Permanent genesis config id. */
-  genesisConfigId: Hex.Hex
   /** Bootstrap config carried by the transaction, when present. */
   init?: MultisigConfig.Config | undefined
 }) => MultisigConfig.Config | Promise<MultisigConfig.Config | undefined> | undefined
@@ -509,6 +495,8 @@ export type Sponsor = {
   account: LocalAccount
   /** Fee token to set before fee payer signing. */
   feeToken?: Address | undefined
+  /** Called once the fee payer has signed, before any broadcast. */
+  onSponsored?: Sponsorship.handleRawTransaction.Options['onSponsored']
   /** Resolves the default fee token for raw sponsorship. */
   resolveFeeToken?:
     | ((chainId: number) => Address | Promise<Address | undefined> | undefined)
@@ -570,8 +558,6 @@ export type Operation = {
   config?: MultisigConfig.Config | undefined
   /** Creation timestamp in milliseconds. */
   createdAt: number
-  /** Permanent genesis config id. */
-  genesisConfigId: Hex.Hex
   /** Deterministic operation id. */
   id: Hex.Hex
   /** Whether the finalized transaction must carry the genesis init config. */
@@ -598,8 +584,6 @@ export type Status = {
   account: Address
   /** Transaction chain id. */
   chainId: number
-  /** Permanent genesis config id. */
-  genesisConfigId: Hex.Hex
   /** Deterministic operation id. */
   id: Hex.Hex
   /** Number of collected owner approvals. */
@@ -627,7 +611,6 @@ function parse(serialized: Hex.Hex) {
   const chainId = Number(transaction['chainId'])
   const id = MultisigConfig.getSignPayload({
     account: signature.account,
-    genesisConfigId: signature.genesisConfigId,
     payload,
   })
   const init = signature.init ? MultisigConfig.from(signature.init) : undefined
@@ -636,7 +619,6 @@ function parse(serialized: Hex.Hex) {
   return {
     account: signature.account,
     chainId,
-    genesisConfigId: signature.genesisConfigId,
     id,
     init,
     nonce,
@@ -652,7 +634,6 @@ function isMultisigSignature(value: unknown): value is SignatureEnvelope.Multisi
     value !== null &&
     (value as { type?: unknown }).type === 'multisig' &&
     typeof (value as { account?: unknown }).account === 'string' &&
-    typeof (value as { genesisConfigId?: unknown }).genesisConfigId === 'string' &&
     Array.isArray((value as { signatures?: unknown }).signatures)
   )
 }
@@ -660,50 +641,39 @@ function isMultisigSignature(value: unknown): value is SignatureEnvelope.Multisi
 async function resolveValidatedConfig(options: {
   account: Address
   chainId: number
-  genesisConfigId: Hex.Hex
   init?: MultisigConfig.Config | undefined
   pending?: Operation | undefined
   resolveConfig?: ResolveConfig | undefined
 }) {
-  const { account, chainId, genesisConfigId, init, pending, resolveConfig } = options
-  const config =
-    (await resolveConfig?.({ account, chainId, genesisConfigId, init })) ?? pending?.config ?? init
+  const { account, chainId, init, pending, resolveConfig } = options
+  const config = (await resolveConfig?.({ account, chainId, init })) ?? pending?.config ?? init
   if (!config) return undefined
 
-  if (init && !isGenesisConfig(init, genesisConfigId))
-    throw new RpcResponse.InvalidParamsError({
-      message: 'Bootstrap multisig init config does not match genesis config id.',
-    })
-
   const normalized = MultisigConfig.from(config)
-  const account_expected = MultisigConfig.getAddress({ genesisConfigId })
-  if (account_expected.toLowerCase() !== account.toLowerCase())
+  if (
+    init &&
+    MultisigConfig.getAddress(MultisigConfig.from(init)).toLowerCase() !== account.toLowerCase()
+  )
     throw new RpcResponse.InvalidParamsError({
-      message: 'Resolved multisig config does not match account or genesis config id.',
+      message: 'Bootstrap multisig init config does not match the multisig account.',
     })
   return normalized
 }
 
 function resolveInitConfig(options: {
   config: MultisigConfig.Config
-  genesisConfigId: Hex.Hex
   init?: MultisigConfig.Config | undefined
   nonce?: number | undefined
   pending?: Operation | undefined
 }) {
-  const { config, genesisConfigId, init, nonce, pending } = options
+  const { config, init, nonce, pending } = options
   if (pending?.initConfig) return pending.initConfig
-  if (pending?.init && pending.config && isGenesisConfig(pending.config, genesisConfigId))
-    return pending.config
+  if (pending?.init && pending.config) return pending.config
   if (init) return init
-  if (nonce === 0 && isGenesisConfig(config, genesisConfigId)) return config
+  if (nonce === 0) return config
   return undefined
 }
 
-function isGenesisConfig(config: MultisigConfig.Config, genesisConfigId: Hex.Hex) {
-  return MultisigConfig.toId(config).toLowerCase() === genesisConfigId.toLowerCase()
-}
-
 function mergeSignatures(signatures: readonly Hex.Hex[]) {
   const seen = new Set<string>()
   const out: Hex.Hex[] = []
@@ -719,12 +689,11 @@ function mergeSignatures(signatures: readonly Hex.Hex[]) {
 function getApprovals(options: {
   account: Address
   config: MultisigConfig.Config
-  genesisConfigId: Hex.Hex
   payload: Hex.Hex
   signatures: readonly Hex.Hex[]
 }) {
-  const { account, config, genesisConfigId, payload } = options
-  const digest = MultisigConfig.getSignPayload({ account, genesisConfigId, payload })
+  const { account, config, payload } = options
+  const digest = MultisigConfig.getSignPayload({ account, payload })
   const owners = new Map(
     config.owners.map((owner) => [
       owner.owner.toLowerCase(),
@@ -764,7 +733,6 @@ function getApprovals(options: {
 
 async function serializeFinal(options: {
   account: Address
-  genesisConfigId: Hex.Hex
   init?: MultisigConfig.Config | undefined
   signatures: readonly Hex.Hex[]
   transaction: Record<string, unknown>
@@ -804,13 +772,11 @@ async function serializeFinal(options: {
   const signatures = options.signatures.map((approval) => SignatureEnvelope.from(approval))
   const sorted = SignatureEnvelope.sortMultisigApprovals({
     account: options.account,
-    genesisConfigId: options.genesisConfigId,
     payload,
     signatures,
   })
   const signature = SignatureEnvelope.from({
     account: options.account,
-    genesisConfigId: options.genesisConfigId,
     signatures: sorted,
     ...(options.init ? { init: options.init } : {}),
   })
@@ -847,7 +813,6 @@ function toStatus(options: {
   return {
     account: operation.account,
     chainId: operation.chainId,
-    genesisConfigId: operation.genesisConfigId,
     id: operation.id,
     signatures: approvals.signatures.length,
     status: operation.status,

package/src/handlers/internal/sponsorship.ts

@@ -1,4 +1,4 @@
-import { RpcResponse, Signature } from 'ox'
+import { Hash, type Hex, RpcResponse, Signature } from 'ox'
 import { TxEnvelopeTempo } from 'ox/tempo'
 import type { Address, Client } from 'viem'
 import type { LocalAccount } from 'viem/accounts'
@@ -6,6 +6,15 @@ import { Transaction } from 'viem/tempo'
 
 import * as Utils from './utils.js'
 
+/**
+ * Sponsorship approval callback. The candidate always carries its `chainId`:
+ * raw submissions deserialize it, and fills validate only prepared/filled
+ * transactions.
+ */
+export type Validate = (
+  request: Transaction.TransactionRequest & { chainId?: number | Hex.Hex | undefined },
+) => boolean | Promise<boolean>
+
 /** Returns sponsor metadata for `eth_fillTransaction` responses. */
 export function getSponsor(options: getSponsor.Options): getSponsor.ReturnType {
   const { account, name, url } = options
@@ -53,7 +62,7 @@ export declare namespace shouldSponsor {
     /** Filled transaction to validate. */
     transaction: Record<string, unknown>
     /** Optional sponsorship approval callback. */
-    validate?: ((request: Transaction.TransactionRequest) => boolean | Promise<boolean>) | undefined
+    validate?: Validate | undefined
   }
 }
 
@@ -88,13 +97,28 @@ export async function sign(options: sign.Options) {
     })
   if (!account.sign) throw new Error('Fee payer account cannot sign transactions.')
 
-  const feePayerSignature = Signature.from(
-    await account.sign({
-      hash: TxEnvelopeTempo.getFeePayerSignPayload(TxEnvelopeTempo.from(prepared as never), {
-        sender: prepared.from,
-      }),
-    }),
-  )
+  const chainId = Utils.resolveChainId(transaction['chainId'])
+  if (chainId === undefined)
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Transaction chainId must be provided before fee payer signing.',
+    })
+
+  const envelope = TxEnvelopeTempo.from(prepared as never)
+  const signPayload = TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender: prepared.from })
+  const feePayerSignature = Signature.from(await account.sign({ hash: signPayload }))
+
+  // Awaited before the signature leaves the relay: a fill-signed envelope can
+  // broadcast anywhere (even directly to a node), so the commitment records as
+  // an intent — no transaction hash until the sender signs.
+  const feeToken = transaction['feeToken'] as Address | null | undefined
+  await options.onSponsored?.({
+    chainId,
+    ...(feeToken ? { feeToken } : {}),
+    method: 'eth_fillTransaction',
+    sender: prepared.from,
+    signPayload,
+    transaction: TxEnvelopeTempo.serialize(envelope, { feePayerSignature }),
+  })
 
   return { ...prepared, feePayerSignature }
 }
@@ -103,6 +127,8 @@ export declare namespace sign {
   type Options = {
     /** Account used as the fee payer. */
     account: LocalAccount
+    /** Called once the fee payer has signed the fill. Awaited: a throw aborts the fill. */
+    onSponsored?: ((event: SponsoredEvent) => Promise<void> | void) | undefined
     /** Filled transaction to sign. */
     transaction: Record<string, unknown>
     /** Sender address from the original request. */
@@ -146,16 +172,25 @@ export async function handleRawTransaction(options: handleRawTransaction.Options
     })
 
   const envelope = TxEnvelopeTempo.from(transaction_sponsored as never)
-  const feePayerSignature = Signature.from(
-    await account.sign({
-      hash: TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender }),
-    }),
-  )
+  const signPayload = TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender })
+  const feePayerSignature = Signature.from(await account.sign({ hash: signPayload }))
   const serializedTransaction = TxEnvelopeTempo.serialize(envelope, {
     feePayerSignature,
     signature: transaction.signature,
   })
 
+  // Awaited before any broadcast so a recording failure refuses sponsorship —
+  // no sponsored transaction ever reaches the chain unrecorded.
+  await options.onSponsored?.({
+    chainId: transaction.chainId,
+    ...(feeToken ? { feeToken } : {}),
+    method,
+    sender,
+    signPayload,
+    transaction: serializedTransaction,
+    transactionHash: Hash.keccak256(serializedTransaction),
+  })
+
   // Raw-sign requests stop after fee-payer signature is added; send methods broadcast it.
   if (method === 'eth_signRawTransaction') return serializedTransaction
   return await client.request({
@@ -176,11 +211,35 @@ export declare namespace handleRawTransaction {
     getClient: (chainId?: number) => Client
     /** Raw transaction method to handle. */
     method: 'eth_signRawTransaction' | 'eth_sendRawTransaction' | 'eth_sendRawTransactionSync'
+    /** Called once the fee payer has signed, before any broadcast. Awaited: a throw aborts the request. */
+    onSponsored?: ((event: SponsoredEvent) => Promise<void> | void) | undefined
     /** Incoming JSON-RPC request. */
     request: { params?: readonly unknown[] | undefined }
     /** Sender address to use if it cannot be recovered from the raw envelope. */
     sender?: Address | undefined
     /** Optional sponsorship approval callback. */
-    validate?: ((request: Transaction.TransactionRequest) => boolean | Promise<boolean>) | undefined
+    validate?: Validate | undefined
   }
 }
+
+/** Facts of one sponsorship commitment, emitted at fee-payer signing time. */
+export type SponsoredEvent = {
+  /** Chain the sponsored transaction targets. */
+  chainId: number
+  /** Fee token the sponsorship resolved, when known. */
+  feeToken?: Address | undefined
+  /** Method that triggered sponsorship: a fill (intent) or a raw submission. */
+  method:
+    | 'eth_fillTransaction'
+    | 'eth_signRawTransaction'
+    | 'eth_sendRawTransaction'
+    | 'eth_sendRawTransactionSync'
+  /** Transaction sender. */
+  sender: Address
+  /** Fee-payer sign payload — a stable identity for the sponsored envelope. */
+  signPayload: Hex.Hex
+  /** Serialized sponsored transaction (sender-unsigned for fill intents). */
+  transaction: Hex.Hex
+  /** Transaction hash (keccak256 of the signed envelope); absent for fill intents, whose senders have not signed yet. */
+  transactionHash?: Hex.Hex | undefined
+}

package/src/handlers/{internal/relay.localnet.test.ts → relay.test.ts}

@@ -5,8 +5,8 @@ import { fillTransaction, sendTransactionSync } from 'viem/actions'
 import { Actions, Addresses, Capabilities, Tick, Transaction, VirtualAddress } from 'viem/tempo'
 import { tempo, tempoModerato } from 'viem/tempo/chains'
 
-import * as Relay from '../../../test/Relay.js'
-import * as Runtime from '../../../test/runtime.js'
+import * as Relay from '../../test/Relay.js'
+import * as Runtime from '../../test/runtime.js'
 
 type Server = Relay.Server