@bsv/sdk 2.0.0-beta.0 → 2.0.0

package/src/primitives/__tests/ReaderUint8Array.test.ts

@@ -0,0 +1,317 @@
+import BigNumber from '../BigNumber'
+import { ReaderUint8Array, Writer, toHex } from '../utils'
+
+describe('ReaderUint8Array', () => {
+  it('should make a new Br', () => {
+    let br = new ReaderUint8Array()
+    expect(br).toBeDefined()
+    br = new ReaderUint8Array()
+    expect(br).toBeDefined()
+  })
+
+  it('should create a new ReaderUint8Array with an Array', () => {
+    const arr: number[] = []
+    const br = new ReaderUint8Array(arr)
+    expect(br).toBeDefined()
+    expect(br.bin instanceof Uint8Array).toBeTruthy()
+  })
+
+  describe('#eof', () => {
+    it('should return true for a blank br', () => {
+      const br = new ReaderUint8Array([...Buffer.from([])])
+      expect(br.eof()).toBeTruthy()
+    })
+  })
+
+  describe('#read', () => {
+    it('should return the same buffer', () => {
+      const buf = Buffer.from([0])
+      const br = new ReaderUint8Array([...buf])
+      expect(Buffer.from(br.read()).toString('hex')).toEqual(
+        buf.toString('hex')
+      )
+    })
+  })
+
+  it('should return a buffer of this length', () => {
+    const buf = Buffer.alloc(10)
+    buf.fill(0)
+    const br = new ReaderUint8Array([...buf])
+    const buf2 = br.read(2)
+    expect(buf2.length).toEqual(2)
+    expect(br.eof()).toBeFalsy()
+    expect(br.pos).toEqual(2)
+  })
+
+  it('should be able to read 0 bytes', () => {
+    const buf = Buffer.from('0101', 'hex')
+    expect(new ReaderUint8Array([...buf]).read(0).length).toEqual(0)
+  })
+})
+
+describe('#readReverse', () => {
+  it('should reverse this [0, 1]', () => {
+    const buf = Buffer.from([0, 1])
+    const br = new ReaderUint8Array([...buf])
+    expect(toHex(br.readReverse())).toEqual('0100')
+  })
+
+  it('should be able to read 0 bytes', () => {
+    const buf = Buffer.from('0101', 'hex')
+    expect(new ReaderUint8Array([...buf]).readReverse(0).length).toEqual(0)
+  })
+})
+
+describe('#readUInt8', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(1)
+    buf.writeUInt8(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt8()).toEqual(1)
+  })
+})
+
+describe('#readInt8', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(1)
+    buf.writeInt8(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt8()).toEqual(1)
+    const bufNegative = Buffer.from('ff', 'hex')
+    const brNegative = new ReaderUint8Array([...bufNegative])
+    expect(brNegative.readInt8()).toEqual(-1)
+  })
+})
+
+describe('#readUInt16BE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(2)
+    buf.writeUInt16BE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt16BE()).toEqual(1)
+  })
+})
+
+describe('#readInt16BE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(2)
+    buf.writeInt16BE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt16BE()).toEqual(1)
+    const bufNegative = Buffer.from('ffff', 'hex')
+    const brNegative = new ReaderUint8Array([...bufNegative])
+    expect(brNegative.readInt8()).toEqual(-1)
+  })
+})
+
+describe('#readUInt16LE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(2)
+    buf.writeUInt16LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt16LE()).toEqual(1)
+  })
+})
+
+describe('#readInt16LE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(2)
+    buf.writeInt16LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt16LE()).toEqual(1)
+    const bufNegative = Buffer.from('ffff', 'hex')
+    const brNegative = new ReaderUint8Array([...bufNegative])
+    expect(brNegative.readInt8()).toEqual(-1)
+  })
+})
+
+describe('#readUInt32BE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(4)
+    buf.writeUInt32BE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt32BE()).toEqual(1)
+  })
+})
+
+describe('#readInt32BE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(4)
+    buf.writeInt32BE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt32BE()).toEqual(1)
+    const bufNegative = Buffer.from('ffffffff', 'hex')
+    const brNegative = new ReaderUint8Array([...bufNegative])
+    expect(brNegative.readInt8()).toEqual(-1)
+  })
+})
+
+describe('#readUInt32LE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(4)
+    buf.writeUInt32LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt32LE()).toEqual(1)
+  })
+})
+
+describe('#readInt32LE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(4)
+    buf.writeInt32LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt32LE()).toEqual(1)
+    expect(
+      new ReaderUint8Array([...Buffer.from('ffffffff', 'hex')]).readInt32LE()
+    ).toEqual(-1)
+  })
+})
+
+describe('#readUInt64BEBn', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0)
+    buf.writeUInt32BE(1, 4)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64BEBn().toNumber()).toEqual(1)
+  })
+
+  it('should return 2^64', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0xff)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64BEBn().toHex()).toEqual('ffffffffffffffff')
+  })
+})
+
+describe('#readUInt64LEBn', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0)
+    buf.writeUInt32LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64LEBn().toNumber()).toEqual(1)
+  })
+
+  it('should return 2^30', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0)
+    buf.writeUInt32LE(Math.pow(2, 30), 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64LEBn().toNumber()).toEqual(Math.pow(2, 30))
+  })
+
+  it('should return 0', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64LEBn().toNumber()).toEqual(0)
+  })
+
+  it('should return 2^64', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0xff)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64LEBn().toHex()).toEqual('ffffffffffffffff')
+  })
+})
+
+describe('#readVarInt', () => {
+  it('should read a 1 byte varInt', () => {
+    const buf = Buffer.from([50])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarInt().length).toEqual(1)
+  })
+
+  it('should read a 3 byte varInt', () => {
+    const buf = Buffer.from([253, 253, 0])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarInt().length).toEqual(3)
+  })
+
+  it('should read a 5 byte varInt', () => {
+    const buf = Buffer.from([254, 0, 0, 0, 0])
+    buf.writeUInt32LE(50000, 1)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarInt().length).toEqual(5)
+  })
+
+  it('should read a 9 byte varInt', () => {
+    const buf = new Writer()
+      .writeVarIntBn(new BigNumber(Math.pow(2, 54).toString()))
+      .toArray()
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarInt().length).toEqual(9)
+  })
+})
+
+describe('#readVarIntNum', () => {
+  it('should read a 1 byte varInt', () => {
+    const buf = Buffer.from([50])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntNum()).toEqual(50)
+  })
+
+  it('should read a 3 byte varInt', () => {
+    const buf = Buffer.from([253, 253, 0])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntNum()).toEqual(253)
+  })
+
+  it('should read a 5 byte varInt', () => {
+    const buf = Buffer.from([254, 0, 0, 0, 0])
+    buf.writeUInt32LE(50000, 1)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntNum()).toEqual(50000)
+  })
+
+  it('should throw an error on a 9 byte varInt over the javascript uint precision limit', () => {
+    const buf = new Writer()
+      .writeVarIntBn(new BigNumber(Math.pow(2, 54).toString()))
+      .toArray()
+    const br = new ReaderUint8Array([...buf])
+    expect(() => {
+      br.readVarIntNum()
+    }).toThrow('number too large to retain precision - use readVarIntBn')
+  })
+
+  it('should not throw an error on a 9 byte varInt not over the javascript uint precision limit', () => {
+    const buf = new Writer()
+      .writeVarIntBn(new BigNumber(Math.pow(2, 53).toString()))
+      .toArray()
+    const br = new ReaderUint8Array([...buf])
+    expect(() => {
+      br.readVarIntNum()
+    }).not.toThrow('number too large to retain precision - use readVarIntBn')
+  })
+})
+
+describe('#readVarIntBn', () => {
+  it('should read a 1 byte varInt', () => {
+    const buf = Buffer.from([50])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntBn().toNumber()).toEqual(50)
+  })
+
+  it('should read a 3 byte varInt', () => {
+    const buf = Buffer.from([253, 253, 0])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntBn().toNumber()).toEqual(253)
+  })
+
+  it('should read a 5 byte varInt', () => {
+    const buf = Buffer.from([254, 0, 0, 0, 0])
+    buf.writeUInt32LE(50000, 1)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntBn().toNumber()).toEqual(50000)
+  })
+
+  it('should read a 9 byte varInt', () => {
+    const buf = Buffer.concat([
+      Buffer.from([255]),
+      Buffer.from('ffffffffffffffff', 'hex')
+    ])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntBn().toHex()).toEqual('ffffffffffffffff')
+  })
+})

package/src/primitives/__tests/WriterUint8Array.test.ts

@@ -0,0 +1,208 @@
+import BigNumber from '../BigNumber'
+import { Reader, encode, WriterUint8Array } from '../utils'
+
+describe('WriterUint8Array', () => {
+  it('should create a new buffer writer', () => {
+    const bw = new WriterUint8Array()
+    expect(bw).toBeDefined()
+  })
+
+  describe('#getLength', () => {
+    it('should compute length correctly of two 2-byte buffers', () => {
+      const buf1 = Buffer.from('0000', 'hex')
+      const buf2 = Buffer.from('0000', 'hex')
+      const bw = new WriterUint8Array().write([...buf1]).write([...buf2])
+      expect(bw.getLength()).toEqual(4)
+    })
+  })
+
+  describe('#toArray', () => {
+    it('should concat these two bufs', () => {
+      const buf1 = [0]
+      const buf2 = [1]
+      const bw = new WriterUint8Array([buf1, buf2])
+      expect(encode(bw.toArray(), 'hex')).toEqual('0001')
+    })
+  })
+
+  describe('#write', () => {
+    it('should write a buffer', () => {
+      const buf = [0]
+      const bw = new WriterUint8Array()
+      bw.write(buf)
+      expect(encode(bw.toArray(), 'hex')).toEqual('00')
+    })
+  })
+
+  describe('#writeReverse', () => {
+    it('should write a buffer in reverse', () => {
+      const buf = [0, 1]
+      const bw = new WriterUint8Array()
+      bw.writeReverse(buf)
+      expect(encode(bw.toArray(), 'hex')).toEqual('0100')
+    })
+  })
+
+  describe('#writeUInt8', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt8(1).toArray(), 'hex')).toEqual('01')
+    })
+  })
+
+  describe('#writeInt8', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt8(1).toArray(), 'hex')).toEqual('01')
+      expect(encode(new WriterUint8Array().writeInt8(-1).toArray(), 'hex')).toEqual('ff')
+    })
+  })
+
+  describe('#writeUInt16BE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt16BE(1).toArray(), 'hex')).toEqual('0001')
+    })
+  })
+
+  describe('#writeInt16BE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt16BE(1).toArray(), 'hex')).toEqual('0001')
+      expect(encode(new WriterUint8Array().writeInt16BE(-1).toArray(), 'hex')).toEqual(
+        'ffff'
+      )
+    })
+  })
+
+  describe('#writeUInt16LE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt16LE(1).toArray(), 'hex')).toEqual('0100')
+    })
+  })
+
+  describe('#writeInt16LE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt16LE(1).toArray(), 'hex')).toEqual('0100')
+      expect(encode(new WriterUint8Array().writeInt16LE(-1).toArray(), 'hex')).toEqual(
+        'ffff'
+      )
+    })
+  })
+
+  describe('#writeUInt32BE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt32BE(1).toArray(), 'hex')).toEqual('00000001')
+    })
+  })
+
+  describe('#writeInt32BE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt32BE(1).toArray(), 'hex')).toEqual('00000001')
+      expect(encode(new WriterUint8Array().writeInt32BE(-1).toArray(), 'hex')).toEqual(
+        'ffffffff'
+      )
+    })
+  })
+
+  describe('#writeUInt32LE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt32LE(1).toArray(), 'hex')).toEqual('01000000')
+    })
+  })
+
+  describe('#writeInt32LE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt32LE(1).toArray(), 'hex')).toEqual('01000000')
+      expect(encode(new WriterUint8Array().writeInt32LE(-1).toArray(), 'hex')).toEqual(
+        'ffffffff'
+      )
+    })
+  })
+
+  describe('#writeUInt64BEBn', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(
+        encode(bw.writeUInt64BEBn(new BigNumber(1)).toArray(), 'hex')
+      ).toEqual('0000000000000001')
+    })
+  })
+
+  describe('#writeUInt64LEBn', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(
+        encode(bw.writeUInt64LEBn(new BigNumber(1)).toArray(), 'hex')
+      ).toEqual('0100000000000000')
+    })
+  })
+
+  describe('#writeVarInt', () => {
+    it('should write a 1 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntNum(1)
+      expect(bw.toArray().length).toEqual(1)
+    })
+
+    it('should write a 3 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntNum(1000)
+      expect(bw.toArray().length).toEqual(3)
+    })
+
+    it('should write a 5 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntNum(Math.pow(2, 16 + 1))
+      expect(bw.toArray().length).toEqual(5)
+    })
+
+    it('should write a 9 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntNum(Math.pow(2, 32 + 1))
+      expect(bw.toArray().length).toEqual(9)
+    })
+
+    it('should read back the same value it wrote for a 9 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      const n = Math.pow(2, 53)
+      expect(n).toEqual(n + 1) // javascript number precision limit
+      bw.writeVarIntNum(n)
+      const br = new Reader(bw.toArray())
+      expect(br.readVarIntBn().toHex()).toEqual('20000000000000')
+    })
+  })
+
+  describe('#writeVarIntBn', () => {
+    it('should write a 1 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntBn(new BigNumber(1))
+      expect(bw.toArray().length).toEqual(1)
+    })
+
+    it('should write a 3 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntBn(new BigNumber(1000))
+      expect(bw.toArray().length).toEqual(3)
+    })
+
+    it('should write a 5 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      const bn = new BigNumber(Math.pow(2, 16 + 1))
+      bw.writeVarIntBn(bn)
+      expect(bw.toArray().length).toEqual(5)
+    })
+
+    it('should write a 9 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntBn(new BigNumber(Math.pow(2, 32 + 1)))
+      expect(bw.toArray().length).toEqual(9)
+    })
+  })
+})

package/src/primitives/utils.ts

@@ -1,6 +1,11 @@
 import BigNumber from './BigNumber.js'
 import { hash256 } from './Hash.js'
 import { assertValidHex } from './hex.js'
+import { WriterUint8Array } from './WriterUint8Array.js'
+import { ReaderUint8Array } from './ReaderUint8Array.js'
+
+export { WriterUint8Array }
+export { ReaderUint8Array }
 
 const BufferCtor =
   typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
@@ -32,7 +37,7 @@ for (let i = 0; i < 256; i++) {
     HEX_DIGITS[(i >> 4) & 0xf] + HEX_DIGITS[i & 0xf]
 }
 
-export const toHex = (msg: number[]): string => {
+export const toHex = (msg: number[] | Uint8Array): string => {
   if (CAN_USE_BUFFER) {
     return BufferCtor.from(msg).toString('hex')
   }
@@ -44,11 +49,24 @@ export const toHex = (msg: number[]): string => {
   return out.join('')
 }
 
+/**
+ * Converts various message formats into a Uint8Array.
+ * Supports Uint8Array, arrays of bytes, hexadecimal strings, base64 strings, and UTF-8 strings.
+ *
+ * @param {any} msg - The input message (Uint8Array, number[], Array or string).
+ * @param {('hex' | 'utf8' | 'base64')} enc - Specifies the string encoding, if applicable.
+ * @returns {Uint8Array}
+ */
+export const toUint8Array = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): Uint8Array => {
+  if (msg instanceof Uint8Array) return msg
+  return new Uint8Array(toArray(msg, enc))
+}
+
 /**
  * Converts various message formats into an array of numbers.
  * Supports arrays, hexadecimal strings, base64 strings, and UTF-8 strings.
  *
- * @param {any} msg - The input message (array or string).
+ * @param {any} msg - The input message (Uint8Array, number[], Array or string).
  * @param {('hex' | 'utf8' | 'base64')} enc - Specifies the string encoding, if applicable.
  * @returns {any[]} - Array representation of the input.
  */
@@ -403,6 +421,10 @@ export class Writer {
     return ret
   }
 
+  toHex (): string {
+    return this.toArray().map((n) => n.toString(16).padStart(2, '0')).join('')
+  }
+
   write (buf: WriterChunk): this {
     this.bufs.push(buf)
     this.length += buf.length
@@ -496,8 +518,13 @@ export class Writer {
   }
 
   writeUInt64LE (n: number): this {
-    const buf = new BigNumber(n).toArray('be', 8)
-    this.writeReverse(buf)
+    if (n === -1) {
+      // This value is used as a dummy satoshis value when serializing OTDA placeholder output for SIGHASH_SINGLE
+      this.write(new Array(8).fill(0xff))
+    } else {
+      const buf = new BigNumber(n).toArray('be', 8)
+      this.writeReverse(buf)
+    }
     return this
   }
 

package/src/remittance/CommsLayer.ts

@@ -0,0 +1,41 @@
+import type { PeerMessage } from './types.js'
+import type { PubKeyHex } from '../wallet/Wallet.interfaces.js'
+
+/**
+ * Abstract communications layer.
+ *
+ * This intentionally mirrors the essential subset of message-box-client / MessageBoxClient.
+ * RemittanceManager never talks directly to HTTP/WebSockets – it only uses this interface.
+ */
+export interface CommsLayer {
+  /**
+   * Sends a message over the store-and-forward channel. Returns the transport messageId.
+   */
+  sendMessage: (args: { recipient: PubKeyHex, messageBox: string, body: string }, hostOverride?: string) => Promise<string>
+
+  /**
+   * Sends a message over the live channel (e.g. WebSocket). Returns the transport messageId.
+   * Implementers may throw if live sending is not possible.
+   * RemittanceManager will fall back to sendMessage where appropriate.
+   */
+  sendLiveMessage?: (args: { recipient: PubKeyHex, messageBox: string, body: string }, hostOverride?: string) => Promise<string>
+
+  /**
+   * Lists pending messages for a message box.
+   */
+  listMessages: (args: { messageBox: string, host?: string }) => Promise<PeerMessage[]>
+
+  /**
+   * Acknowledges messages (deletes them from the server / inbox).
+   */
+  acknowledgeMessage: (args: { messageIds: string[] }) => Promise<void>
+
+  /**
+   * Optional live listener.
+   */
+  listenForLiveMessages?: (args: {
+    messageBox: string
+    overrideHost?: string
+    onMessage: (msg: PeerMessage) => void
+  }) => Promise<void>
+}

package/src/remittance/IdentityLayer.ts

@@ -0,0 +1,32 @@
+import type {
+  IdentityVerificationRequest,
+  IdentityVerificationResponse,
+  IdentityVerificationAcknowledgment,
+  ThreadId,
+  ModuleContext,
+  Termination
+} from './types.js'
+import { PubKeyHex } from '../wallet/Wallet.interfaces.js'
+
+/**
+ * The Identity Layer handles identity certificate exchange and verification.
+ * It is optional and pluggable.
+ * Modules can use it to request/verify identity before accepting settlements.
+ *
+ * The runtime configuration can be used to determine whether and at what point identity
+ * exchange occurs: before invoicing, before settlement, etc.
+ *
+ * Makers and takers can both implement this layer as needed, and request/respond to
+ * identity verification at different points in the protocol.
+ */
+export interface IdentityLayer {
+  /** Determine which certificates to request from a counterparty. */
+  determineCertificatesToRequest: (args: { counterparty: PubKeyHex, threadId: ThreadId }, ctx: ModuleContext) => Promise<IdentityVerificationRequest>
+  /** Respond to an incoming identity verification request. */
+  respondToRequest: (
+    args: { counterparty: PubKeyHex, threadId: ThreadId, request: IdentityVerificationRequest },
+    ctx: ModuleContext
+  ) => Promise<{ action: 'respond', response: IdentityVerificationResponse } | { action: 'terminate', termination: Termination }>
+  /** Assess whether received certificates satisfy the requirements for transaction settlement. */
+  assessReceivedCertificateSufficiency: (counterparty: PubKeyHex, received: IdentityVerificationResponse, threadId: ThreadId) => Promise<IdentityVerificationAcknowledgment | Termination>
+}