# encodeCall

Creates a transaction from a function call.

# Type

;<T extends new (...args: any) => any, K extends keyof InstanceType<T>>(params: {
  target: InstanceType<T>
  property: string
  args: Parameters<InstanceType<T>[K]>
  mod?: string
}) =>
  Promise<{
    tx: NakamotoJS.Transaction
    effect: { res: Json; env: Json }
  }>

# Parameters

# `params`

An object with the configuration parameters to encode the expression in a transaction.

Key	Type	Description
target	InstanceType<T>	The smart object on which to call the function
property	string	The name of the function being called
args	Parameters<InstanceType<T>[K]>	The arguments to the function call
mod	string	A module specifier

Module specifiers are encoded as strings of the form <transaction id>:<output number>

# Return Value

# Description

# Example

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

// A smart contract
class Counter extends Contract {
  n: number

  constructor() {
    super({ n: 0 })
  }

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

describe('encodeCall', async () => {
  it('Should encode a function call', async () => {
    // Create and fund wallet
    const computer = new Computer({ chain, network, url })
    await computer.faucet(1e8)

    // Create an on-chain object from the smart contract
    const counter = await computer.new(Counter, [])

    // Encode a function call
    const { tx } = await computer.encodeCall({
      target: counter,
      property: 'inc',
      args: [],
    })

    // Decode the meta data
    expect(await computer.decode(tx)).to.deep.eq({
      exp: `__bc__.inc()`,
      env: { __bc__: counter._rev },
      mod: '',
    })

    // Broadcast the tx to commit the change
    await computer.broadcast(tx)
  })
})