# Mock

Mocking is a technique for spending objects that are associated with Bitcoin Computer transactions that have not been broadcast yet. This is required for advanced applications like swaps and for using smart contracts over payment channels (see here for more information).

A mocked object is an object that has _id, _rev and _root set to strings of the form mock-${hex}:${num} where hex is a string of 64 hexadecimal characters and num is a number. The Bitcoin Computer library exports a class Mock to make it easy to create a mock.

const makeRev = () => `mock-${'0'.repeat(64)}:${Math.floor(Math.random() * 1000000)}`

export class Mock {
  _id: string
  _rev: string
  _root: string
  _amount: number
  _owners: string | string[]

  constructor(opts = { _id: rev(), _rev: rev(), _root: rev() }) {
    Object.entries(opts).forEach(([key, value]) => {
      this[key] = value
    })
  }
}

# Example

The example below shows how a mocked object can be used. Note that the object a is created after the transaction that spends it. Thus the revision of a is not known when tx is built. Once a is created on-chain and its revision becomes known, the code below updated the input of tx to spend the revision of a.

import { Computer, Mock } from '@bitcoin-computer/lib'
import { chain, network, url, expect } from '../../utils'

// A smart contract
class A extends Contract {
  n: number
  constructor() {
    super({ n: 1 })
  }

  inc() {
    this.n += 1
  }
}

// A mock contract
class M extends Mock {
  n: number
  constructor() {
    super()
    this.n = 1
  }

  inc() {
    this.n += 1
  }
}

describe('Mock', async () => {
  // Create client side wallet on regtest
  const computer = new Computer({ chain, network, url })

  before('Fund client side wallet on regtest', async () => {
    await computer.faucet(3e8)
  })

  it('Should spend a mocked object if the object is created first', async () => {
    // Create mock
    const m = new M()

    // Create smart object
    const a = await computer.new(A, [])

    // Update smart object
    const { tx: incTx } = await computer.encode({
      exp: `a.inc()`,
      env: { a: a._rev },
      mocks: { a: m },
    })
    await computer.broadcast(incTx)
  })

  it('Should spend a mocked object if the mock is created first', async () => {
    // Create mock
    const m = new M()

    // Create transaction in update off-chain object
    const { tx: incTx } = await computer.encode({
      // The update expression
      exp: `a.inc()`,

      // Assume value m for variable a
      mocks: { a: m },

      // Specify that the input that spends a points to m._rev
      env: { a: m._rev },

      // The transaction can only be funded and signed once it is finalized
      fund: false,
      sign: false,
    })

    // Create on-chain object
    const a = await computer.new(A, [])

    // Update the outpoint of the first inputs to point to a._rev
    const [txId, i] = a._rev.split(':')
    const index = parseInt(i, 10)
    incTx.updateInput(0, { txId, index })

    // Fund, sign and send transaction
    await computer.fund(incTx)
    await computer.sign(incTx)
    await computer.broadcast(incTx)
  })
})