@bsv/sdk 2.1.0 → 2.1.2

package/src/wallet/substrates/XDM.ts

@@ -12,11 +12,11 @@ export default class XDMSubstrate extends InvokableWalletBase {
 
   constructor(domain: string = '*') {
     super()
-    if (typeof window !== 'object') {
-      throw new Error('The XDM substrate requires a global window object.')
+    if (typeof globalThis.window !== 'object') {
+      throw new TypeError('The XDM substrate requires a global window object.')
     }
-    if (typeof window.postMessage !== 'function') {
-      throw new Error(
+    if (typeof globalThis.window.postMessage !== 'function') {
+      throw new TypeError(
         'The window object does not seem to support postMessage calls.'
       )
     }

package/src/wallet/substrates/__tests/HTTPWalletJSON.test.ts

@@ -7,6 +7,10 @@ import { WERR_REVIEW_ACTIONS } from '../../WERR_REVIEW_ACTIONS'
 // Helpers
 // ---------------------------------------------------------------------------
 
+const TEST_ORIGINATOR = 'example.com'
+const TEST_ORIGIN_HEADER = 'http://example.com'
+const BASE_URL = 'http://localhost:3321'
+
 /** Build a minimal fetch mock that resolves with a JSON-shaped Response. */
 function makeFetch(
   body: unknown,
@@ -24,19 +28,23 @@ function makeNetworkErrorFetch(message = 'Network failure'): jest.Mock {
   return jest.fn().mockRejectedValue(new Error(message))
 }
 
+function makeClient(mockFetch: jest.Mock): HTTPWalletJSON {
+  return new HTTPWalletJSON(TEST_ORIGINATOR, BASE_URL, mockFetch as unknown as typeof fetch)
+}
+
 // ---------------------------------------------------------------------------
 // Constructor
 // ---------------------------------------------------------------------------
 
 describe('HTTPWalletJSON – constructor', () => {
   it('stores the provided baseUrl', () => {
-    const client = new HTTPWalletJSON('example.com', 'http://my-server:9000')
+    const client = new HTTPWalletJSON(TEST_ORIGINATOR, 'http://my-server:9000')
     expect(client.baseUrl).toBe('http://my-server:9000')
   })
 
   it('uses http://localhost:3321 as the default baseUrl', () => {
-    const client = new HTTPWalletJSON('example.com')
-    expect(client.baseUrl).toBe('http://localhost:3321')
+    const client = new HTTPWalletJSON(TEST_ORIGINATOR)
+    expect(client.baseUrl).toBe(BASE_URL)
   })
 
   it('stores the originator', () => {
@@ -44,14 +52,9 @@ describe('HTTPWalletJSON – constructor', () => {
     expect(client.originator).toBe('wallet.example.com')
   })
 
-  it('accepts undefined originator', () => {
-    const client = new HTTPWalletJSON(undefined)
-    expect(client.originator).toBeUndefined()
-  })
-
   it('stores the custom httpClient', () => {
     const mockFetch = jest.fn()
-    const client = new HTTPWalletJSON('example.com', 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = new HTTPWalletJSON(TEST_ORIGINATOR, BASE_URL, mockFetch as unknown as typeof fetch)
     expect(client.httpClient).toBe(mockFetch)
   })
 })
@@ -63,13 +66,13 @@ describe('HTTPWalletJSON – constructor', () => {
 describe('HTTPWalletJSON – api() successful responses', () => {
   it('POSTs to the correct URL and returns the parsed body', async () => {
     const mockFetch = makeFetch({ version: '1.0.0.0.0.0.0' })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     const result = await client.getVersion({})
 
     expect(mockFetch).toHaveBeenCalledTimes(1)
     const [url, init] = mockFetch.mock.calls[0] as [string, RequestInit]
-    expect(url).toBe('http://localhost:3321/getVersion')
+    expect(url).toBe(`${BASE_URL}/getVersion`)
     expect(init.method).toBe('POST')
     expect(JSON.parse(init.body as string)).toEqual({})
     expect(result).toEqual({ version: '1.0.0.0.0.0.0' })
@@ -77,7 +80,7 @@ describe('HTTPWalletJSON – api() successful responses', () => {
 
   it('sets Accept and Content-Type headers', async () => {
     const mockFetch = makeFetch({ height: 800000 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     await client.getHeight({})
 
@@ -85,17 +88,27 @@ describe('HTTPWalletJSON – api() successful responses', () => {
     const headers = init.headers as Record<string, string>
     expect(headers['Accept']).toBe('application/json')
     expect(headers['Content-Type']).toBe('application/json')
+    expect(headers['Origin']).toBe(TEST_ORIGIN_HEADER)
+    expect(headers['Originator']).toBe(TEST_ORIGIN_HEADER)
   })
 
   it('serialises args as JSON in the request body', async () => {
     const mockFetch = makeFetch({ actions: [], totalActions: 0 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     await client.listActions({ labels: ['test-label'] })
 
     const [, init] = mockFetch.mock.calls[0] as [string, RequestInit]
     expect(JSON.parse(init.body as string)).toEqual({ labels: ['test-label'] })
   })
+
+  it('throws before making a request in Node when originator is missing', async () => {
+    const mockFetch = makeFetch({ version: '1.0.0.0.0.0.0' })
+    const client = new HTTPWalletJSON(undefined, BASE_URL, mockFetch as unknown as typeof fetch)
+
+    await expect(client.getVersion({})).rejects.toThrow('HTTPWalletJSON: originator is required')
+    expect(mockFetch).not.toHaveBeenCalled()
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -111,7 +124,7 @@ describe('HTTPWalletJSON – api() error responses', () => {
       message: 'The description parameter must be at least 5 length.',
     }
     const mockFetch = makeFetch(errorBody, { ok: false, status: 400 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     await expect(client.createAction({ description: 'x' })).rejects.toThrow(WERR_INVALID_PARAMETER)
 
@@ -133,7 +146,7 @@ describe('HTTPWalletJSON – api() error responses', () => {
       message: 'Custom server message for lockingScript.',
     }
     const mockFetch = makeFetch(errorBody, { ok: false, status: 400 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     try {
       await client.createAction({ description: 'hello world' })
@@ -151,7 +164,7 @@ describe('HTTPWalletJSON – api() error responses', () => {
       moreSatoshisNeeded: 2000,
     }
     const mockFetch = makeFetch(errorBody, { ok: false, status: 400 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     await expect(client.createAction({ description: 'hello world' })).rejects.toThrow(WERR_INSUFFICIENT_FUNDS)
 
@@ -174,7 +187,7 @@ describe('HTTPWalletJSON – api() error responses', () => {
       txid: 'abc123',
     }
     const mockFetch = makeFetch(errorBody, { ok: false, status: 400 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     await expect(client.createAction({ description: 'hello world' })).rejects.toThrow(WERR_REVIEW_ACTIONS)
 
@@ -190,7 +203,7 @@ describe('HTTPWalletJSON – api() error responses', () => {
 
   it('throws a generic Error when the server returns a non-400 error status', async () => {
     const mockFetch = makeFetch({ message: 'Internal Server Error' }, { ok: false, status: 500 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     await expect(client.getVersion({})).rejects.toThrow(Error)
 
@@ -205,7 +218,7 @@ describe('HTTPWalletJSON – api() error responses', () => {
 
   it('falls back to "HTTP Client error <status>" when the 500 body has no message', async () => {
     const mockFetch = makeFetch({}, { ok: false, status: 503 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     try {
       await client.getVersion({})
@@ -219,7 +232,7 @@ describe('HTTPWalletJSON – api() error responses', () => {
     // code 99 is unrecognised – falls through to the generic error path
     const errorBody = { isError: true, code: 99, message: 'Unknown problem' }
     const mockFetch = makeFetch(errorBody, { ok: false, status: 400 })
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     await expect(client.getVersion({})).rejects.toThrow(Error)
   })
@@ -232,7 +245,7 @@ describe('HTTPWalletJSON – api() error responses', () => {
 describe('HTTPWalletJSON – network errors', () => {
   it('propagates a fetch rejection as-is', async () => {
     const mockFetch = makeNetworkErrorFetch('Failed to fetch')
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     await expect(client.getVersion({})).rejects.toThrow('Failed to fetch')
   })
@@ -248,7 +261,7 @@ describe('HTTPWalletJSON – method routing', () => {
 
   beforeEach(() => {
     mockFetch = makeFetch({})
-    client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    client = makeClient(mockFetch)
   })
 
   const expectCallName = async (method: () => Promise<unknown>, expectedPath: string) => {
@@ -470,7 +483,7 @@ describe('HTTPWalletJSON – response body passthrough', () => {
   it('returns the exact JSON body from a successful getVersion call', async () => {
     const expected = { version: '1.0.0.0.0.0.0' }
     const mockFetch = makeFetch(expected)
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     const result = await client.getVersion({})
     expect(result).toEqual(expected)
@@ -479,7 +492,7 @@ describe('HTTPWalletJSON – response body passthrough', () => {
   it('returns the exact JSON body from a successful listActions call', async () => {
     const expected = { totalActions: 2, actions: [{ txid: 'aa', status: 'completed' }] }
     const mockFetch = makeFetch(expected)
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     const result = await client.listActions({ labels: [] })
     expect(result).toEqual(expected)
@@ -488,7 +501,7 @@ describe('HTTPWalletJSON – response body passthrough', () => {
   it('returns the exact JSON body from a successful getNetwork call', async () => {
     const expected = { network: 'mainnet' as const }
     const mockFetch = makeFetch(expected)
-    const client = new HTTPWalletJSON(undefined, 'http://localhost:3321', mockFetch as unknown as typeof fetch)
+    const client = makeClient(mockFetch)
 
     const result = await client.getNetwork({})
     expect(result).toEqual(expected)

package/src/wallet/substrates/__tests/ReactNativeWebView.test.ts

@@ -0,0 +1,174 @@
+import ReactNativeWebView from '../ReactNativeWebView'
+import { WalletError } from '../../WalletError'
+import * as Utils from '../../../primitives/utils'
+
+describe('ReactNativeWebView', () => {
+  let originalWindow: typeof global.window
+  let addEventListenerMock: jest.Mock
+  let removeEventListenerMock: jest.Mock
+  let postMessageMock: jest.Mock
+
+  beforeEach(() => {
+    originalWindow = global.window
+    addEventListenerMock = jest.fn()
+    removeEventListenerMock = jest.fn()
+    postMessageMock = jest.fn()
+
+    global.window = {
+      ReactNativeWebView: {
+        postMessage: postMessageMock
+      },
+      addEventListener: addEventListenerMock,
+      removeEventListener: removeEventListenerMock
+    } as unknown as Window & typeof globalThis
+  })
+
+  afterEach(() => {
+    global.window = originalWindow
+    jest.restoreAllMocks()
+  })
+
+  const getMessageListener = (): ((event: { data: string }) => void) => {
+    const call = addEventListenerMock.mock.calls.at(-1)
+    if (call == null) {
+      throw new Error('No message listener registered.')
+    }
+    return call[1] as (event: { data: string }) => void
+  }
+
+  const dispatchMessage = (data: unknown): void => {
+    getMessageListener()({ data: JSON.stringify(data) })
+  }
+
+  describe('constructor', () => {
+    it('throws if window is not available', () => {
+      ;(global as any).window = undefined
+
+      expect(() => new ReactNativeWebView()).toThrow(
+        'The XDM substrate requires a global window object.'
+      )
+    })
+
+    it('throws if ReactNativeWebView is not bound to window', () => {
+      delete (global.window as any).ReactNativeWebView
+
+      expect(() => new ReactNativeWebView()).toThrow(
+        'The window object does not have a ReactNativeWebView property.'
+      )
+    })
+
+    it('throws if ReactNativeWebView does not support postMessage', () => {
+      ;(global.window as any).ReactNativeWebView.postMessage = undefined
+
+      expect(() => new ReactNativeWebView()).toThrow(
+        'The window.ReactNativeWebView property does not seem to support postMessage calls.'
+      )
+    })
+  })
+
+  describe('invoke', () => {
+    it('posts an invocation message to the React Native bridge', () => {
+      jest.spyOn(Utils, 'toBase64').mockReturnValue('request-id')
+      const substrate = new ReactNativeWebView()
+
+      void substrate.invoke('getVersion', {})
+
+      expect(addEventListenerMock).toHaveBeenCalledWith('message', expect.any(Function))
+      expect(postMessageMock).toHaveBeenCalledWith(
+        JSON.stringify({
+          type: 'CWI',
+          isInvocation: true,
+          id: 'request-id',
+          call: 'getVersion',
+          args: {}
+        })
+      )
+    })
+
+    it('resolves the result from a matching response', async () => {
+      jest.spyOn(Utils, 'toBase64').mockReturnValue('request-id')
+      const substrate = new ReactNativeWebView()
+
+      const promise = substrate.invoke('getVersion', {})
+      dispatchMessage({
+        type: 'CWI',
+        isInvocation: false,
+        id: 'request-id',
+        status: 'success',
+        result: { version: '1.0.0' }
+      })
+
+      await expect(promise).resolves.toEqual({ version: '1.0.0' })
+      expect(removeEventListenerMock).toHaveBeenCalledWith('message', expect.any(Function))
+    })
+
+    it('rejects matching error responses as WalletError', async () => {
+      jest.spyOn(Utils, 'toBase64').mockReturnValue('request-id')
+      const substrate = new ReactNativeWebView()
+
+      const promise = substrate.invoke('createAction', { description: 'Test action' })
+      dispatchMessage({
+        type: 'CWI',
+        isInvocation: false,
+        id: 'request-id',
+        status: 'error',
+        description: 'Action was rejected',
+        code: 123
+      })
+
+      await expect(promise).rejects.toThrow(WalletError)
+      await expect(promise).rejects.toThrow('Action was rejected')
+      await promise.catch((err) => {
+        expect(err.code).toBe(123)
+      })
+      expect(removeEventListenerMock).toHaveBeenCalledWith('message', expect.any(Function))
+    })
+
+    it('ignores unrelated response messages', async () => {
+      jest.spyOn(Utils, 'toBase64').mockReturnValue('request-id')
+      const substrate = new ReactNativeWebView()
+      const promise = substrate.invoke('getVersion', {})
+      let settled = false
+      promise.then(
+        () => { settled = true },
+        () => { settled = true }
+      )
+
+      dispatchMessage({
+        type: 'other',
+        isInvocation: false,
+        id: 'request-id',
+        status: 'success',
+        result: {}
+      })
+      dispatchMessage({
+        type: 'CWI',
+        isInvocation: false,
+        id: 'other-id',
+        status: 'success',
+        result: {}
+      })
+      dispatchMessage({
+        type: 'CWI',
+        isInvocation: true,
+        id: 'request-id',
+        status: 'success',
+        result: {}
+      })
+
+      await new Promise((resolve) => setTimeout(resolve, 1))
+      expect(settled).toBe(false)
+      expect(removeEventListenerMock).not.toHaveBeenCalled()
+
+      dispatchMessage({
+        type: 'CWI',
+        isInvocation: false,
+        id: 'request-id',
+        status: 'success',
+        result: { version: '1.0.0' }
+      })
+
+      await expect(promise).resolves.toEqual({ version: '1.0.0' })
+    })
+  })
+})

package/src/wallet/substrates/__tests/window.CWI.test.ts

@@ -0,0 +1,256 @@
+import WindowCWISubstrate from '../window.CWI'
+
+const originator = 'example.com'
+
+const methodCases = [
+  {
+    methodName: 'createAction',
+    args: { description: 'Test description', inputs: [], outputs: [] },
+    result: { txid: 'abc123' }
+  },
+  {
+    methodName: 'signAction',
+    args: { spends: {}, reference: 'someReference' },
+    result: { txid: 'abc123' }
+  },
+  {
+    methodName: 'abortAction',
+    args: { reference: 'someReference' },
+    result: { aborted: true }
+  },
+  {
+    methodName: 'listActions',
+    args: { labels: [] },
+    result: { totalActions: 0, actions: [] }
+  },
+  {
+    methodName: 'internalizeAction',
+    args: { tx: 'someTx', outputs: [], description: 'Test description' },
+    result: { accepted: true }
+  },
+  {
+    methodName: 'listOutputs',
+    args: { basket: 'someBasket' },
+    result: { totalOutputs: 0, outputs: [] }
+  },
+  {
+    methodName: 'relinquishOutput',
+    args: { basket: 'someBasket', output: 'someOutput' },
+    result: { relinquished: true }
+  },
+  {
+    methodName: 'getPublicKey',
+    args: { identityKey: true },
+    result: { publicKey: 'somePubKey' }
+  },
+  {
+    methodName: 'revealCounterpartyKeyLinkage',
+    args: { counterparty: 'someCounterparty', verifier: 'someVerifier' },
+    result: {
+      prover: 'someProver',
+      verifier: 'someVerifier',
+      counterparty: 'someCounterparty',
+      revelationTime: 'someTime',
+      encryptedLinkage: [],
+      encryptedLinkageProof: []
+    }
+  },
+  {
+    methodName: 'revealSpecificKeyLinkage',
+    args: {
+      counterparty: 'someCounterparty',
+      verifier: 'someVerifier',
+      protocolID: [0, 'someProtocol'],
+      keyID: 'someKeyID'
+    },
+    result: {
+      prover: 'someProver',
+      verifier: 'someVerifier',
+      counterparty: 'someCounterparty',
+      protocolID: [0, 'someProtocol'],
+      keyID: 'someKeyID',
+      encryptedLinkage: [],
+      encryptedLinkageProof: [],
+      proofType: 1
+    }
+  },
+  {
+    methodName: 'encrypt',
+    args: { plaintext: [], protocolID: [0, 'someProtocol'], keyID: 'someKeyID' },
+    result: { ciphertext: [] }
+  },
+  {
+    methodName: 'decrypt',
+    args: { ciphertext: [], protocolID: [0, 'someProtocol'], keyID: 'someKeyID' },
+    result: { plaintext: [] }
+  },
+  {
+    methodName: 'createHmac',
+    args: { data: [], protocolID: [0, 'someProtocol'], keyID: 'someKeyID' },
+    result: { hmac: [] }
+  },
+  {
+    methodName: 'verifyHmac',
+    args: { data: [], hmac: [], protocolID: [0, 'someProtocol'], keyID: 'someKeyID' },
+    result: { valid: true }
+  },
+  {
+    methodName: 'createSignature',
+    args: { data: [], protocolID: [0, 'someProtocol'], keyID: 'someKeyID' },
+    result: { signature: [] }
+  },
+  {
+    methodName: 'verifySignature',
+    args: { data: [], signature: [], protocolID: [0, 'someProtocol'], keyID: 'someKeyID' },
+    result: { valid: true }
+  },
+  {
+    methodName: 'acquireCertificate',
+    args: {
+      type: 'someType',
+      subject: 'someSubject',
+      serialNumber: 'someSerialNumber',
+      revocationOutpoint: 'someOutpoint',
+      signature: 'someSignature',
+      fields: {},
+      certifier: 'someCertifier',
+      keyringRevealer: 'certifier',
+      keyringForSubject: {},
+      acquisitionProtocol: 'direct'
+    },
+    result: {
+      type: 'someType',
+      subject: 'someSubject',
+      serialNumber: 'someSerialNumber',
+      certifier: 'someCertifier',
+      revocationOutpoint: 'someOutpoint',
+      signature: 'someSignature',
+      fields: {}
+    }
+  },
+  {
+    methodName: 'listCertificates',
+    args: { certifiers: [], types: [] },
+    result: { totalCertificates: 0, certificates: [] }
+  },
+  {
+    methodName: 'proveCertificate',
+    args: {
+      certificate: {
+        type: 'someType',
+        subject: 'someSubject',
+        serialNumber: 'someSerialNumber',
+        certifier: 'someCertifier',
+        revocationOutpoint: 'someOutpoint',
+        signature: 'someSignature',
+        fields: {}
+      },
+      fieldsToReveal: [],
+      verifier: 'someVerifier'
+    },
+    result: { keyringForVerifier: {} }
+  },
+  {
+    methodName: 'relinquishCertificate',
+    args: { type: 'someType', serialNumber: 'someSerialNumber', certifier: 'someCertifier' },
+    result: { relinquished: true }
+  },
+  {
+    methodName: 'discoverByIdentityKey',
+    args: { identityKey: 'someIdentityKey' },
+    result: { totalCertificates: 0, certificates: [] }
+  },
+  {
+    methodName: 'discoverByAttributes',
+    args: { attributes: {} },
+    result: { totalCertificates: 0, certificates: [] }
+  },
+  {
+    methodName: 'isAuthenticated',
+    args: {},
+    result: { authenticated: true }
+  },
+  {
+    methodName: 'waitForAuthentication',
+    args: {},
+    result: { authenticated: true }
+  },
+  {
+    methodName: 'getHeight',
+    args: {},
+    result: { height: 1000 }
+  },
+  {
+    methodName: 'getHeaderForHeight',
+    args: { height: 1000 },
+    result: { header: 'someHeader' }
+  },
+  {
+    methodName: 'getNetwork',
+    args: {},
+    result: { network: 'mainnet' }
+  },
+  {
+    methodName: 'getVersion',
+    args: {},
+    result: { version: '1.0.0' }
+  }
+]
+
+describe('WindowCWISubstrate', () => {
+  let originalWindow: typeof global.window
+  let mockCWI: Record<string, jest.Mock>
+
+  beforeEach(() => {
+    originalWindow = global.window
+    mockCWI = Object.fromEntries(
+      methodCases.map(({ methodName, result }) => [
+        methodName,
+        jest.fn().mockResolvedValue(result)
+      ])
+    )
+    global.window = {
+      CWI: mockCWI
+    } as unknown as Window & typeof globalThis
+  })
+
+  afterEach(() => {
+    global.window = originalWindow
+    jest.restoreAllMocks()
+  })
+
+  it('throws if window is not available', () => {
+    ;(global as any).window = undefined
+
+    expect(() => new WindowCWISubstrate()).toThrow(
+      'The window.CWI substrate requires a global window object.'
+    )
+  })
+
+  it('throws if window.CWI is not bound', () => {
+    delete (global.window as any).CWI
+
+    expect(() => new WindowCWISubstrate()).toThrow(
+      'The window.CWI interface does not appear to be bound to the window object.'
+    )
+  })
+
+  it('binds the CWI object that exists at construction time', async () => {
+    const substrate = new WindowCWISubstrate()
+    const replacement = {
+      getVersion: jest.fn().mockResolvedValue({ version: '2.0.0' })
+    }
+    ;(global.window as any).CWI = replacement
+
+    await expect(substrate.getVersion({})).resolves.toEqual({ version: '1.0.0' })
+    expect(mockCWI.getVersion).toHaveBeenCalledWith({}, undefined)
+    expect(replacement.getVersion).not.toHaveBeenCalled()
+  })
+
+  test.each(methodCases)('delegates $methodName to window.CWI', async ({ methodName, args, result }) => {
+    const substrate = new WindowCWISubstrate()
+
+    await expect((substrate as any)[methodName](args, originator)).resolves.toEqual(result)
+    expect(mockCWI[methodName]).toHaveBeenCalledWith(args, originator)
+  })
+})