libnexakotlin/org.nexa.libnexakotlin

Package-level declarations

Introduction

This library is comprehensive and therefore complex. Learning it is best accomplished via example code, with this documentation used as a reference. The library contains Wallet, Blockchain, Network and Scripting sections. All are needed to implement a fully-functional Nexa wallet, but portions can be used separately if full functionality is not needed.

Basic Objects

Multiple blockchains are supported via the ChainSelector object. Currently this includes Nexa and Bitcoin Cash, and all of the secondary (i.e. regtest and testnet) networks for these two blockchains.

This is accomplished using a class hierarchy, with interfaces designated by iXXXX (for example iBlockHeader, iBlock, iTransaction, iTxInput, iTxOutput, iTxOutpoint). These interfaces are implemented by a class that implements common functionality "CommonBlockHeader", and this class is the parent of blockchain-specific derived classes (NexaBlockHeader, BchBlockHeader).

Rather than create instances of blockchain-specific classes, it is best to use the "xxxFor" and "xxxFrom" APIs (blockFor, blockFromHex, blockHeaderFor, txFor, txFromHex, txInputFor, txOutputFor).
These "factory" APIs create the correct derived class, returning the interface type. Using them, it is surprising how much common code can be written that works across both BCH and NEXA, and potentially other UTXO-based chains.

Blockchains and Wallets

APIs exist to create wallets, launch blockchains, and attach the two. Right now, a wallet can only attach to a single blockchain. See newWallet, openWallet, and deleteWallet.

Blockchain

The Blockchain class represents a blockchain and synchronizes with the public chain. It stores block headers to a database and has APIs to query the chain.

Blockchain objects (Blocks and Transactions)

Although one may create Nexa or Bch objects directly, it is recommended that construction of blockchain objects occur via global helper functions:

These functions will create the correct blockchain-specific derived class, returning the parent iXXXX object. By doing this whenever possible, you maximize the likelihood that your source code will apply to multiple blockchains. To use blockchain-specific functionality, you may downcast "(header as NexaBlockHeader)" when needed.

Network Access

You may access either P2P or Electrum nodes in the network via the RequestMgr class. This class automatically manages connection for you. Going lower, you may directly connect to a specific node via the P2pClient or ElectrumClient classes.

Scripting

Full scripting functionality is available via the OP class, which captures all opcodes, and via the SatoshiScript and ScriptTemplate classes.
The SatoshiScript class is the generalized script language. ScriptTemplate creates the Nexa-specific script template transaction output. Note that a partner library Nexa Script Machine can be used to execute and debug these scripts.

Wallet

At the top level, the Bip44Wallet exists to create an manage a bip-44 compliant (meaning based on a 12-word recovery key) wallet. If set up, this object automatically uses the Blockchain Network and Scripting APIs to automatically sync with the blockchain and parse and create transactions. However, it is also possible to use this object in an offline mode, simply by not "hooking" it to a network object. After creating this object, use the Wallet interface for general purpose functionality, to allow your code to work with any wallet type.

Example

import org.nexa.libnexakotlin.*

class Test
{

    fun docObjectExample()
    {
        // This is the Nexa genesis block
        val hdr = blockFromHex(ChainSelector.NEXA, "00000000000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000000000000000000000000000000000000000000cdafb522e41f4b94618c8ee546f0fab8aaae7057f80e4730ea32df145dec73910000000000000000000000000000000000000000000000000000000000000000c0b2b16200ffffff00000000000000000000000000000000000000000000000000000000007201000000000000010000000403001700010000020000000000000000000100000000000000000000a06a00023b1c4c99526575746572733a204a6170616e20504d204b697368696461206261636b7320424f4a20756c7472612d6561737920706f6c696379207768696c652079656e20776f7272696573206d6f756e74204254433a3734313731313a3030303030303030303030303030303030303037356634626330386531643738613361623361663832373464313333333463306163326465323533303937363800000000")
        println("Height ${hdr.height} Size ${hdr.size} Chain Work ${hdr.chainWork}")
        val tx = hdr.txes[0]
        println("Tx 0 inputs: ${tx.inputs.size}")
        println("Tx 0 outputs: ${tx.outputs.size}")

        // I'm cheating here a little because I know this is the genesis block so I know that the last output
        // of the last transaction is text within an OP_RETURN script.
        val output0Asm = tx.outputs.last().script.toAsm(" ")
        println("tx 0 output 0: $output0Asm")
        val stmts = tx.outputs.last().script.parsed()
        println("\nNexa genesis block says:" + OP.parse(stmts.last()).data!!.decodeUtf8())

        // Create a regtest address object
        val addr = PayAddress("nexareg:nqtsq5g53q3sqyhhp45a86792a7wkkm3gyw9gylhp7kr703l")
    }
    
    fun docWalletExample()
    {
        // This needs to be run before APIs are called, but you should do a single time upon app startup
        initializeLibNexa()

        // This call automatically creates the underlying blockchain object if it hasn't already been created.
        val wal = openOrNewWallet("exampleWallet", ChainSelector.NEXAREGTEST)
        while(!wal.synced())
        {
            // Note that the blockchain may also be syncing headers simultaneously with the wallet syncing, so both
            // numbers may increase.
            //
            // Sync also depends on time -- if the synced block isn't recent enough the wallet does not believe its
            // synced.  So if you are using REGTEST make sure you have recently created a new block before running this test.
            println("syncing ${wal.chainstate?.syncedHeight} of ${wal.blockchain.curHeight}..." )
            millisleep(2000U)
        }

        val newAddress = wal.getNewAddress()
        println("wallet balance is: ${wal.balance}. An address for this wallet is ${newAddress}.")
        try
        {
            // send some coins to myself.  Amounts in this library are ALWAYS in the finest unit.
            wal.send(10000, wal.getNewAddress())
        }
        catch (e: WalletNotEnoughBalanceException)
        {
            if (wal.balance <= 10000) println("You don't have enough coins to actually send.")
        }
    }

}

Introduction

Basic Objects

Blockchains and Wallets

APIs exist to create wallets, launch blockchains, and attach the two. Right now, a wallet can only attach to a single blockchain. See newWallet, openWallet, and deleteWallet.

Blockchain

The Blockchain class represents a blockchain and synchronizes with the public chain. It stores block headers to a database and has APIs to query the chain.

Blockchain objects (Blocks and Transactions)

Although one may create Nexa or Bch objects directly, it is recommended that construction of blockchain objects occur via global helper functions:

Network Access

Scripting

Wallet

Example

import org.nexa.libnexakotlin.*

class Test
{

    fun docObjectExample()
    {
        // This is the Nexa genesis block
        val hdr = blockFromHex(ChainSelector.NEXA, "00000000000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000000000000000000000000000000000000000000cdafb522e41f4b94618c8ee546f0fab8aaae7057f80e4730ea32df145dec73910000000000000000000000000000000000000000000000000000000000000000c0b2b16200ffffff00000000000000000000000000000000000000000000000000000000007201000000000000010000000403001700010000020000000000000000000100000000000000000000a06a00023b1c4c99526575746572733a204a6170616e20504d204b697368696461206261636b7320424f4a20756c7472612d6561737920706f6c696379207768696c652079656e20776f7272696573206d6f756e74204254433a3734313731313a3030303030303030303030303030303030303037356634626330386531643738613361623361663832373464313333333463306163326465323533303937363800000000")
        println("Height ${hdr.height} Size ${hdr.size} Chain Work ${hdr.chainWork}")
        val tx = hdr.txes[0]
        println("Tx 0 inputs: ${tx.inputs.size}")
        println("Tx 0 outputs: ${tx.outputs.size}")

        // I'm cheating here a little because I know this is the genesis block so I know that the last output
        // of the last transaction is text within an OP_RETURN script.
        val output0Asm = tx.outputs.last().script.toAsm(" ")
        println("tx 0 output 0: $output0Asm")
        val stmts = tx.outputs.last().script.parsed()
        println("\nNexa genesis block says:" + OP.parse(stmts.last()).data!!.decodeUtf8())

        // Create a regtest address object
        val addr = PayAddress("nexareg:nqtsq5g53q3sqyhhp45a86792a7wkkm3gyw9gylhp7kr703l")
    }
    
    fun docWalletExample()
    {
        // This needs to be run before APIs are called, but you should do a single time upon app startup
        initializeLibNexa()

        // This call automatically creates the underlying blockchain object if it hasn't already been created.
        val wal = openOrNewWallet("exampleWallet", ChainSelector.NEXAREGTEST)
        while(!wal.synced())
        {
            // Note that the blockchain may also be syncing headers simultaneously with the wallet syncing, so both
            // numbers may increase.
            //
            // Sync also depends on time -- if the synced block isn't recent enough the wallet does not believe its
            // synced.  So if you are using REGTEST make sure you have recently created a new block before running this test.
            println("syncing ${wal.chainstate?.syncedHeight} of ${wal.blockchain.curHeight}..." )
            millisleep(2000U)
        }

        val newAddress = wal.getNewAddress()
        println("wallet balance is: ${wal.balance}. An address for this wallet is ${newAddress}.")
        try
        {
            // send some coins to myself.  Amounts in this library are ALWAYS in the finest unit.
            wal.send(10000, wal.getNewAddress())
        }
        catch (e: WalletNotEnoughBalanceException)
        {
            if (wal.balance <= 10000) println("You don't have enough coins to actually send.")
        }
    }

}

Introduction

Basic Objects

Blockchains and Wallets

APIs exist to create wallets, launch blockchains, and attach the two. Right now, a wallet can only attach to a single blockchain. See newWallet, openWallet, and deleteWallet.

Blockchain

The Blockchain class represents a blockchain and synchronizes with the public chain. It stores block headers to a database and has APIs to query the chain.

Blockchain objects (Blocks and Transactions)

Although one may create Nexa or Bch objects directly, it is recommended that construction of blockchain objects occur via global helper functions:

Network Access

Scripting

Wallet

Example

import org.nexa.libnexakotlin.*

class Test
{

    fun docObjectExample()
    {
        // This is the Nexa genesis block
        val hdr = blockFromHex(ChainSelector.NEXA, "00000000000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000000000000000000000000000000000000000000cdafb522e41f4b94618c8ee546f0fab8aaae7057f80e4730ea32df145dec73910000000000000000000000000000000000000000000000000000000000000000c0b2b16200ffffff00000000000000000000000000000000000000000000000000000000007201000000000000010000000403001700010000020000000000000000000100000000000000000000a06a00023b1c4c99526575746572733a204a6170616e20504d204b697368696461206261636b7320424f4a20756c7472612d6561737920706f6c696379207768696c652079656e20776f7272696573206d6f756e74204254433a3734313731313a3030303030303030303030303030303030303037356634626330386531643738613361623361663832373464313333333463306163326465323533303937363800000000")
        println("Height ${hdr.height} Size ${hdr.size} Chain Work ${hdr.chainWork}")
        val tx = hdr.txes[0]
        println("Tx 0 inputs: ${tx.inputs.size}")
        println("Tx 0 outputs: ${tx.outputs.size}")

        // I'm cheating here a little because I know this is the genesis block so I know that the last output
        // of the last transaction is text within an OP_RETURN script.
        val output0Asm = tx.outputs.last().script.toAsm(" ")
        println("tx 0 output 0: $output0Asm")
        val stmts = tx.outputs.last().script.parsed()
        println("\nNexa genesis block says:" + OP.parse(stmts.last()).data!!.decodeUtf8())

        // Create a regtest address object
        val addr = PayAddress("nexareg:nqtsq5g53q3sqyhhp45a86792a7wkkm3gyw9gylhp7kr703l")
    }
    
    fun docWalletExample()
    {
        // This needs to be run before APIs are called, but you should do a single time upon app startup
        initializeLibNexa()

        // This call automatically creates the underlying blockchain object if it hasn't already been created.
        val wal = openOrNewWallet("exampleWallet", ChainSelector.NEXAREGTEST)
        while(!wal.synced())
        {
            // Note that the blockchain may also be syncing headers simultaneously with the wallet syncing, so both
            // numbers may increase.
            //
            // Sync also depends on time -- if the synced block isn't recent enough the wallet does not believe its
            // synced.  So if you are using REGTEST make sure you have recently created a new block before running this test.
            println("syncing ${wal.chainstate?.syncedHeight} of ${wal.blockchain.curHeight}..." )
            millisleep(2000U)
        }

        val newAddress = wal.getNewAddress()
        println("wallet balance is: ${wal.balance}. An address for this wallet is ${newAddress}.")
        try
        {
            // send some coins to myself.  Amounts in this library are ALWAYS in the finest unit.
            wal.send(10000, wal.getNewAddress())
        }
        catch (e: WalletNotEnoughBalanceException)
        {
            if (wal.balance <= 10000) println("You don't have enough coins to actually send.")
        }
    }

}

Introduction

Basic Objects

Blockchains and Wallets

APIs exist to create wallets, launch blockchains, and attach the two. Right now, a wallet can only attach to a single blockchain. See newWallet, openWallet, and deleteWallet.

Blockchain

The Blockchain class represents a blockchain and synchronizes with the public chain. It stores block headers to a database and has APIs to query the chain.

Blockchain objects (Blocks and Transactions)

Although one may create Nexa or Bch objects directly, it is recommended that construction of blockchain objects occur via global helper functions:

txFor, txFromHex, txInputFor, txOutputFor
blockHeaderFor, blockHeaderFromHex, and merkleBlockFor

Network Access

Scripting

Wallet

Example

import org.nexa.libnexakotlin.*

class Test
{

    fun docObjectExample()
    {
        // This is the Nexa genesis block
        val hdr = blockFromHex(ChainSelector.NEXA, "00000000000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000000000000000000000000000000000000000000cdafb522e41f4b94618c8ee546f0fab8aaae7057f80e4730ea32df145dec73910000000000000000000000000000000000000000000000000000000000000000c0b2b16200ffffff00000000000000000000000000000000000000000000000000000000007201000000000000010000000403001700010000020000000000000000000100000000000000000000a06a00023b1c4c99526575746572733a204a6170616e20504d204b697368696461206261636b7320424f4a20756c7472612d6561737920706f6c696379207768696c652079656e20776f7272696573206d6f756e74204254433a3734313731313a3030303030303030303030303030303030303037356634626330386531643738613361623361663832373464313333333463306163326465323533303937363800000000")
        println("Height ${hdr.height} Size ${hdr.size} Chain Work ${hdr.chainWork}")
        val tx = hdr.txes[0]
        println("Tx 0 inputs: ${tx.inputs.size}")
        println("Tx 0 outputs: ${tx.outputs.size}")

        // I'm cheating here a little because I know this is the genesis block so I know that the last output
        // of the last transaction is text within an OP_RETURN script.
        val output0Asm = tx.outputs.last().script.toAsm(" ")
        println("tx 0 output 0: $output0Asm")
        val stmts = tx.outputs.last().script.parsed()
        println("\nNexa genesis block says:" + OP.parse(stmts.last()).data!!.decodeUtf8())

        // Create a regtest address object
        val addr = PayAddress("nexareg:nqtsq5g53q3sqyhhp45a86792a7wkkm3gyw9gylhp7kr703l")
    }
    
    fun docWalletExample()
    {
        // This needs to be run before APIs are called, but you should do a single time upon app startup
        initializeLibNexa()

        // This call automatically creates the underlying blockchain object if it hasn't already been created.
        val wal = openOrNewWallet("exampleWallet", ChainSelector.NEXAREGTEST)
        while(!wal.synced())
        {
            // Note that the blockchain may also be syncing headers simultaneously with the wallet syncing, so both
            // numbers may increase.
            //
            // Sync also depends on time -- if the synced block isn't recent enough the wallet does not believe its
            // synced.  So if you are using REGTEST make sure you have recently created a new block before running this test.
            println("syncing ${wal.chainstate?.syncedHeight} of ${wal.blockchain.curHeight}..." )
            millisleep(2000U)
        }

        val newAddress = wal.getNewAddress()
        println("wallet balance is: ${wal.balance}. An address for this wallet is ${newAddress}.")
        try
        {
            // send some coins to myself.  Amounts in this library are ALWAYS in the finest unit.
            wal.send(10000, wal.getNewAddress())
        }
        catch (e: WalletNotEnoughBalanceException)
        {
            if (wal.balance <= 10000) println("You don't have enough coins to actually send.")
        }
    }

}

Introduction

Basic Objects

Blockchains and Wallets

APIs exist to create wallets, launch blockchains, and attach the two. Right now, a wallet can only attach to a single blockchain. See newWallet, openWallet, and deleteWallet.

Blockchain

The Blockchain class represents a blockchain and synchronizes with the public chain. It stores block headers to a database and has APIs to query the chain.

Blockchain objects (Blocks and Transactions)

Although one may create Nexa or Bch objects directly, it is recommended that construction of blockchain objects occur via global helper functions:

Network Access

Scripting

Wallet

Example

import org.nexa.libnexakotlin.*

class Test
{

    fun docObjectExample()
    {
        // This is the Nexa genesis block
        val hdr = blockFromHex(ChainSelector.NEXA, "00000000000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000000000000000000000000000000000000000000cdafb522e41f4b94618c8ee546f0fab8aaae7057f80e4730ea32df145dec73910000000000000000000000000000000000000000000000000000000000000000c0b2b16200ffffff00000000000000000000000000000000000000000000000000000000007201000000000000010000000403001700010000020000000000000000000100000000000000000000a06a00023b1c4c99526575746572733a204a6170616e20504d204b697368696461206261636b7320424f4a20756c7472612d6561737920706f6c696379207768696c652079656e20776f7272696573206d6f756e74204254433a3734313731313a3030303030303030303030303030303030303037356634626330386531643738613361623361663832373464313333333463306163326465323533303937363800000000")
        println("Height ${hdr.height} Size ${hdr.size} Chain Work ${hdr.chainWork}")
        val tx = hdr.txes[0]
        println("Tx 0 inputs: ${tx.inputs.size}")
        println("Tx 0 outputs: ${tx.outputs.size}")

        // I'm cheating here a little because I know this is the genesis block so I know that the last output
        // of the last transaction is text within an OP_RETURN script.
        val output0Asm = tx.outputs.last().script.toAsm(" ")
        println("tx 0 output 0: $output0Asm")
        val stmts = tx.outputs.last().script.parsed()
        println("\nNexa genesis block says:" + OP.parse(stmts.last()).data!!.decodeUtf8())

        // Create a regtest address object
        val addr = PayAddress("nexareg:nqtsq5g53q3sqyhhp45a86792a7wkkm3gyw9gylhp7kr703l")
    }
    
    fun docWalletExample()
    {
        // This needs to be run before APIs are called, but you should do a single time upon app startup
        initializeLibNexa()

        // This call automatically creates the underlying blockchain object if it hasn't already been created.
        val wal = openOrNewWallet("exampleWallet", ChainSelector.NEXAREGTEST)
        while(!wal.synced())
        {
            // Note that the blockchain may also be syncing headers simultaneously with the wallet syncing, so both
            // numbers may increase.
            //
            // Sync also depends on time -- if the synced block isn't recent enough the wallet does not believe its
            // synced.  So if you are using REGTEST make sure you have recently created a new block before running this test.
            println("syncing ${wal.chainstate?.syncedHeight} of ${wal.blockchain.curHeight}..." )
            millisleep(2000U)
        }

        val newAddress = wal.getNewAddress()
        println("wallet balance is: ${wal.balance}. An address for this wallet is ${newAddress}.")
        try
        {
            // send some coins to myself.  Amounts in this library are ALWAYS in the finest unit.
            wal.send(10000, wal.getNewAddress())
        }
        catch (e: WalletNotEnoughBalanceException)
        {
            if (wal.balance <= 10000) println("You don't have enough coins to actually send.")
        }
    }

}

Introduction

Basic Objects

Blockchains and Wallets

APIs exist to create wallets, launch blockchains, and attach the two. Right now, a wallet can only attach to a single blockchain. See newWallet, openWallet, and deleteWallet.

Blockchain

The Blockchain class represents a blockchain and synchronizes with the public chain. It stores block headers to a database and has APIs to query the chain.

Blockchain objects (Blocks and Transactions)

Although one may create Nexa or Bch objects directly, it is recommended that construction of blockchain objects occur via global helper functions:

txFor, txFromHex, txInputFor, txOutputFor
blockHeaderFor, blockHeaderFromHex, and merkleBlockFor

Network Access

Scripting

Wallet

Example

import org.nexa.libnexakotlin.*

class Test
{

    fun docObjectExample()
    {
        // This is the Nexa genesis block
        val hdr = blockFromHex(ChainSelector.NEXA, "00000000000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000000000000000000000000000000000000000000cdafb522e41f4b94618c8ee546f0fab8aaae7057f80e4730ea32df145dec73910000000000000000000000000000000000000000000000000000000000000000c0b2b16200ffffff00000000000000000000000000000000000000000000000000000000007201000000000000010000000403001700010000020000000000000000000100000000000000000000a06a00023b1c4c99526575746572733a204a6170616e20504d204b697368696461206261636b7320424f4a20756c7472612d6561737920706f6c696379207768696c652079656e20776f7272696573206d6f756e74204254433a3734313731313a3030303030303030303030303030303030303037356634626330386531643738613361623361663832373464313333333463306163326465323533303937363800000000")
        println("Height ${hdr.height} Size ${hdr.size} Chain Work ${hdr.chainWork}")
        val tx = hdr.txes[0]
        println("Tx 0 inputs: ${tx.inputs.size}")
        println("Tx 0 outputs: ${tx.outputs.size}")

        // I'm cheating here a little because I know this is the genesis block so I know that the last output
        // of the last transaction is text within an OP_RETURN script.
        val output0Asm = tx.outputs.last().script.toAsm(" ")
        println("tx 0 output 0: $output0Asm")
        val stmts = tx.outputs.last().script.parsed()
        println("\nNexa genesis block says:" + OP.parse(stmts.last()).data!!.decodeUtf8())

        // Create a regtest address object
        val addr = PayAddress("nexareg:nqtsq5g53q3sqyhhp45a86792a7wkkm3gyw9gylhp7kr703l")
    }
    
    fun docWalletExample()
    {
        // This needs to be run before APIs are called, but you should do a single time upon app startup
        initializeLibNexa()

        // This call automatically creates the underlying blockchain object if it hasn't already been created.
        val wal = openOrNewWallet("exampleWallet", ChainSelector.NEXAREGTEST)
        while(!wal.synced())
        {
            // Note that the blockchain may also be syncing headers simultaneously with the wallet syncing, so both
            // numbers may increase.
            //
            // Sync also depends on time -- if the synced block isn't recent enough the wallet does not believe its
            // synced.  So if you are using REGTEST make sure you have recently created a new block before running this test.
            println("syncing ${wal.chainstate?.syncedHeight} of ${wal.blockchain.curHeight}..." )
            millisleep(2000U)
        }

        val newAddress = wal.getNewAddress()
        println("wallet balance is: ${wal.balance}. An address for this wallet is ${newAddress}.")
        try
        {
            // send some coins to myself.  Amounts in this library are ALWAYS in the finest unit.
            wal.send(10000, wal.getNewAddress())
        }
        catch (e: WalletNotEnoughBalanceException)
        {
            if (wal.balance <= 10000) println("You don't have enough coins to actually send.")
        }
    }

}

Introduction

Basic Objects

Blockchains and Wallets

APIs exist to create wallets, launch blockchains, and attach the two. Right now, a wallet can only attach to a single blockchain. See newWallet, openWallet, and deleteWallet.

Blockchain

The Blockchain class represents a blockchain and synchronizes with the public chain. It stores block headers to a database and has APIs to query the chain.

Blockchain objects (Blocks and Transactions)

Although one may create Nexa or Bch objects directly, it is recommended that construction of blockchain objects occur via global helper functions:

txFor, txFromHex, txInputFor, txOutputFor
blockHeaderFor, blockHeaderFromHex, and merkleBlockFor

Network Access

Scripting

Wallet

Example

import org.nexa.libnexakotlin.*

class Test
{

    fun docObjectExample()
    {
        // This is the Nexa genesis block
        val hdr = blockFromHex(ChainSelector.NEXA, "00000000000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000000000000000000000000000000000000000000cdafb522e41f4b94618c8ee546f0fab8aaae7057f80e4730ea32df145dec73910000000000000000000000000000000000000000000000000000000000000000c0b2b16200ffffff00000000000000000000000000000000000000000000000000000000007201000000000000010000000403001700010000020000000000000000000100000000000000000000a06a00023b1c4c99526575746572733a204a6170616e20504d204b697368696461206261636b7320424f4a20756c7472612d6561737920706f6c696379207768696c652079656e20776f7272696573206d6f756e74204254433a3734313731313a3030303030303030303030303030303030303037356634626330386531643738613361623361663832373464313333333463306163326465323533303937363800000000")
        println("Height ${hdr.height} Size ${hdr.size} Chain Work ${hdr.chainWork}")
        val tx = hdr.txes[0]
        println("Tx 0 inputs: ${tx.inputs.size}")
        println("Tx 0 outputs: ${tx.outputs.size}")

        // I'm cheating here a little because I know this is the genesis block so I know that the last output
        // of the last transaction is text within an OP_RETURN script.
        val output0Asm = tx.outputs.last().script.toAsm(" ")
        println("tx 0 output 0: $output0Asm")
        val stmts = tx.outputs.last().script.parsed()
        println("\nNexa genesis block says:" + OP.parse(stmts.last()).data!!.decodeUtf8())

        // Create a regtest address object
        val addr = PayAddress("nexareg:nqtsq5g53q3sqyhhp45a86792a7wkkm3gyw9gylhp7kr703l")
    }
    
    fun docWalletExample()
    {
        // This needs to be run before APIs are called, but you should do a single time upon app startup
        initializeLibNexa()

        // This call automatically creates the underlying blockchain object if it hasn't already been created.
        val wal = openOrNewWallet("exampleWallet", ChainSelector.NEXAREGTEST)
        while(!wal.synced())
        {
            // Note that the blockchain may also be syncing headers simultaneously with the wallet syncing, so both
            // numbers may increase.
            //
            // Sync also depends on time -- if the synced block isn't recent enough the wallet does not believe its
            // synced.  So if you are using REGTEST make sure you have recently created a new block before running this test.
            println("syncing ${wal.chainstate?.syncedHeight} of ${wal.blockchain.curHeight}..." )
            millisleep(2000U)
        }

        val newAddress = wal.getNewAddress()
        println("wallet balance is: ${wal.balance}. An address for this wallet is ${newAddress}.")
        try
        {
            // send some coins to myself.  Amounts in this library are ALWAYS in the finest unit.
            wal.send(10000, wal.getNewAddress())
        }
        catch (e: WalletNotEnoughBalanceException)
        {
            if (wal.balance <= 10000) println("You don't have enough coins to actually send.")
        }
    }

}

Introduction

Basic Objects

Blockchains and Wallets

APIs exist to create wallets, launch blockchains, and attach the two. Right now, a wallet can only attach to a single blockchain. See newWallet, openWallet, and deleteWallet.

Blockchain

The Blockchain class represents a blockchain and synchronizes with the public chain. It stores block headers to a database and has APIs to query the chain.

Blockchain objects (Blocks and Transactions)

Although one may create Nexa or Bch objects directly, it is recommended that construction of blockchain objects occur via global helper functions:

Network Access

Scripting

Wallet

Example

import org.nexa.libnexakotlin.*

class Test
{

    fun docObjectExample()
    {
        // This is the Nexa genesis block
        val hdr = blockFromHex(ChainSelector.NEXA, "00000000000000000000000000000000000000000000000000000000000000000000011e0000000000000000000000000000000000000000000000000000000000000000cdafb522e41f4b94618c8ee546f0fab8aaae7057f80e4730ea32df145dec73910000000000000000000000000000000000000000000000000000000000000000c0b2b16200ffffff00000000000000000000000000000000000000000000000000000000007201000000000000010000000403001700010000020000000000000000000100000000000000000000a06a00023b1c4c99526575746572733a204a6170616e20504d204b697368696461206261636b7320424f4a20756c7472612d6561737920706f6c696379207768696c652079656e20776f7272696573206d6f756e74204254433a3734313731313a3030303030303030303030303030303030303037356634626330386531643738613361623361663832373464313333333463306163326465323533303937363800000000")
        println("Height ${hdr.height} Size ${hdr.size} Chain Work ${hdr.chainWork}")
        val tx = hdr.txes[0]
        println("Tx 0 inputs: ${tx.inputs.size}")
        println("Tx 0 outputs: ${tx.outputs.size}")

        // I'm cheating here a little because I know this is the genesis block so I know that the last output
        // of the last transaction is text within an OP_RETURN script.
        val output0Asm = tx.outputs.last().script.toAsm(" ")
        println("tx 0 output 0: $output0Asm")
        val stmts = tx.outputs.last().script.parsed()
        println("\nNexa genesis block says:" + OP.parse(stmts.last()).data!!.decodeUtf8())

        // Create a regtest address object
        val addr = PayAddress("nexareg:nqtsq5g53q3sqyhhp45a86792a7wkkm3gyw9gylhp7kr703l")
    }
    
    fun docWalletExample()
    {
        // This needs to be run before APIs are called, but you should do a single time upon app startup
        initializeLibNexa()

        // This call automatically creates the underlying blockchain object if it hasn't already been created.
        val wal = openOrNewWallet("exampleWallet", ChainSelector.NEXAREGTEST)
        while(!wal.synced())
        {
            // Note that the blockchain may also be syncing headers simultaneously with the wallet syncing, so both
            // numbers may increase.
            //
            // Sync also depends on time -- if the synced block isn't recent enough the wallet does not believe its
            // synced.  So if you are using REGTEST make sure you have recently created a new block before running this test.
            println("syncing ${wal.chainstate?.syncedHeight} of ${wal.blockchain.curHeight}..." )
            millisleep(2000U)
        }

        val newAddress = wal.getNewAddress()
        println("wallet balance is: ${wal.balance}. An address for this wallet is ${newAddress}.")
        try
        {
            // send some coins to myself.  Amounts in this library are ALWAYS in the finest unit.
            wal.send(10000, wal.getNewAddress())
        }
        catch (e: WalletNotEnoughBalanceException)
        {
            if (wal.balance <= 10000) println("You don't have enough coins to actually send.")
        }
    }

}

Types

AddressDerivationKey

class AddressDerivationKey

AndroidLogging

class AndroidLogging(val module: String) : iLogging

AsyncOpTracker

open class AsyncOpTracker(var title: String, val update: suspend (AsyncOpTracker) -> Unit)

AsyncTransactionSigner

class AsyncTransactionSigner(val w: Wallet, val tx: iTransaction, val sigHashType: ByteArray = byteArrayOf(), val coctxt: CoroutineContext, var title: String, val update: suspend (AsyncOpTracker) -> Unit) : CoOpTracker

BadCryptoException

open class BadCryptoException(msg: String = "bad crypto code") : LibNexaException

BadHeadersProvided

open class BadHeadersProvided(val blockHash: Hash256) : HeadersNotForthcoming

BanData

class BanData(val reason: BanReason)

Data related to why we banned a node

BanReason

enum BanReason : Enum<BanReason>

Indicate why we chose not to connect to a node

BchBlock

class BchBlock(val chainSelector: ChainSelector) : BchBlockHeader, iBlock

BchBlockHeader

open class BchBlockHeader : CommonBlockHeader

Header of a block for bitcoin-family cryptocurrencies

BchBlockHeaderDb

class BchBlockHeaderDb(val name: String, val sql: SqlDriver) : BlockHeaderDatabase

BchMerkleBlock

class BchMerkleBlock(val chainSelector: ChainSelector) : BchBlockHeader, iMerkleBlock

A block that contains a subset of the total number of transactions, and includes a merkle proof that the provided transactions are part of the block

BCHserializable

interface BCHserializable

BCHserialized

class BCHserialized(_format: SerializationType, notCopiedData: ByteArray? = null, sizeHint: Int = 1024)

BchTransaction

class BchTransaction(val chainSelector: ChainSelector) : iTransaction

Bitcoin transaction

BchTxInput

class BchTxInput(val chainSelector: ChainSelector) : iTxInput

Spend a coin (aka UTXO, prevout) in a transaction

BchTxOutpoint

data class BchTxOutpoint(val txid: Hash256, var idx: Long) : iTxOutpoint

BchTxOutput

class BchTxOutput(val chainSelector: ChainSelector) : iTxOutput

Output of a bitcoin transaction

Bip44Wallet

class Bip44Wallet(val name: String, val chainSelector: ChainSelector, var wdb: WalletDatabase) : CommonWallet

This wallet uses a single piece of random data, deriving new private keys and addresses using the technique described in BIP-0032 with key derivation paths specified by BIP-043 and BIP-044. In essence, key derivation is: m/'/'/'//index

Bip44WalletData

class Bip44WalletData : BCHserializable

Helper class that saves/loads data needed by the Bip44Wallet

Blockchain

class Blockchain(val chainSelector: ChainSelector, val name: String, val net: CnxnMgr, val genesisBlockHash: Hash256, var checkpointPriorBlockId: Hash256, var checkpointId: Hash256, var checkpointHeight: Long, var checkpointWork: BigInteger, val dbPrefix: String = "blkhdr_", var fullSync: Boolean = true)

Access and track a blockchain

BlockchainException

open class BlockchainException(msg: String, val shortMsg: String? = null, val severity: ErrorSeverity = ErrorSeverity.Abnormal) : LibNexaException

BlockHeaderDatabase

interface BlockHeaderDatabase

BlockHeaderPersist

interface BlockHeaderPersist

BlockLocator

class BlockLocator : BCHserializable

An array of block hashes, starting at the current block, and ending at the genesis block. The creator can skip blocks, populating whatever hashes he feels is most likely to identify a specific chain, closest to the splitoff point. Typically, some kind of exponential backoff is used. For example: The next 10 hashes are the previous 10 blocks (gap 1). After these, the gap is multiplied by 2 for each hash, until the genesis block is added

BlockNotForthcoming

open class BlockNotForthcoming(val blockHash: Hash256) : BlockchainException

BloomFlags

enum BloomFlags : Enum<BloomFlags>

Bloom filter update flags Must be consistent with same named fields in C++ code in bloom.h:bloomflags

ByteArraySlice

class ByteArraySlice(val data: ByteArray, val start: Int, val size: Int)

Bytes

open class Bytes(d: ByteArray) : Comparable<Bytes>

This class is needed because ByteArray's equality is by object, not contents. So ByteArrays probably do not work as you expect as the key in any map-like data structures, for example.

CallAfter

class CallAfter(var doneBits: Long = 0, var fn: () -> Unit? = null)

CallAfterN

class CallAfterN(val fn: () -> Unit?, val count: Long)

Call the passed function after this function has been called 'count times

Callbacker

open class Callbacker<T>

Organize multiple callbacks for a function that accepts a single parameter

Callbacker2

open class Callbacker2<T0, T1>

Organize multiple callbacks for a function that accepts two parameters. This is a convenience class for this common case. For larger numbers of parameters you can always place them in an object or a list and use the single-parameter callbacker

CannotLoadException

open class CannotLoadException(msg: String) : NetException

CapdException

open class CapdException(msg: String, val capdMsg: CapdMsg? = null) : LibNexaException

CapdMsg

class CapdMsg(var data: ByteArray? = null) : BCHserializable

A CAPD message (see https://spec.nexa.org/network/capd/)

CapdProtocolCommunication

class CapdProtocolCommunication(val chain: Blockchain, convoSecret: ByteArray, var coCtxt: CoroutineContext) : ProtocolCommunication

CapdQuery

class CapdQuery(var cookie: Long, var type: Int, var start: Long, var quantity: Long, var content: ByteArray) : BCHserializable

A CAPD message (see https://spec.nexa.org/network/capd/)

CapdTooDifficult

open class CapdTooDifficult(msg: String, val capdMsg: CapdMsg? = null) : CapdException

ChainSelector

enum ChainSelector : Enum<ChainSelector>

Identify the cryptocurrency/blockchain.

cli

annotation class cli(val display: Display, val help: String, val delve: Int = 0)

Indicates that a member field or function should be displayed in the command line interface (if one is enabled). Note that the CLI only works for JVM platforms right now, because it requires reflection.

CnxnMgr

abstract class CnxnMgr(val chainSelector: ChainSelector)

The CnxnMgr handles discovery, connection, and maintenance of all connections into the Peer-2-Peer network. This allows higher layers to treat peers as a grab bag of nodes, ignoring issues like reconnecting, periodically cycling connections, and searching for new nodes.

CoCond

class CoCond<T>(val scope: CoroutineScope)

Behaves like a condition, but for co-routines

Codec

class Codec

CommonBlockHeader

abstract class CommonBlockHeader : iBlockHeader

CommonCnxnMgr

abstract class CommonCnxnMgr(netType: ChainSelector) : CnxnMgr

CommonWallet

abstract class CommonWallet(val name: String, val chainSelector: ChainSelector) : Wallet

This class provides implementations to for functions that are common to many blockchains and wallet types

CoOpTracker

abstract class CoOpTracker(val coctxt: CoroutineContext, var title: String, val update: suspend (AsyncOpTracker) -> Unit) : AsyncOpTracker

DataMissingException

open class DataMissingException(msg: String) : LibNexaException

DecimalFormat

expect class DecimalFormat(fmtSpec: String)

actual class DecimalFormat(val fmtSpec: String)

DeserializationException

open class DeserializationException(msg: String, val shortMsg: String? = null) : LibNexaException

Display

enum Display : Enum<Display>

DisplayStyle

enum DisplayStyle : Enum<DisplayStyle>

DisplayStyles

typealias DisplayStyles = Set<DisplayStyle>

class EJ(val json: JsonElement?)

ElectrumClient

class ElectrumClient(val chainSelector: ChainSelector, val name: String, val port: Int = DEFAULT_NEXA_SSL_ELECTRUM_PORT, val logName: String = name + ":" + port, autostart: Boolean = true, val useSSL: Boolean = true, connectTimeoutMs: Long = JsonRpc.CONNECT_TIMEOUT, accessTimeoutMs: Long = JsonRpc.ACCESS_TIMEOUT) : JsonRpc

Open a JSON-RPC over TCP connection to an Electrum X server

ElectrumConnectError

class ElectrumConnectError(node: String, underlyingError: String) : ElectrumException

Electrum server never replied

ElectrumException

open class ElectrumException(msg: String) : NetException

ElectrumIncorrectReply

class ElectrumIncorrectReply(what: String) : ElectrumException

The reply doesn't adhere to the protocol in some manner

ElectrumIncorrectRequest

class ElectrumIncorrectRequest(what: String) : ElectrumException

The request was not accepted by the server

ElectrumNoNodesException

open class ElectrumNoNodesException : ElectrumException

ElectrumNotFound

class ElectrumNotFound(msg: String) : ElectrumException

A passed entity was not found (transaction, block, scripthash, etc).

ElectrumRequestTimeout

class ElectrumRequestTimeout : ElectrumException

Electrum server never replied

ElectrumShutdown

class ElectrumShutdown : ElectrumException

Electrum server never replied

ErrorSeverity

enum ErrorSeverity : Enum<ErrorSeverity>

exactBytes

class exactBytes(val data: ByteArray)

This class behaves like a function and its sole purpose is to wrap a bytearray into another class so that when we serialize it we know not to include the length

FallbackProvider

class FallbackProvider

FieldContinues

object FieldContinues

FieldDict

typealias FieldDict = MutableMap<String, Nvh?>

FieldFunction

object FieldFunction

GlueWalletBlockchain

class GlueWalletBlockchain(val chain: Blockchain) : BCHserializable

Helper class that glues a wallet to a blockchain

GroupAuthorityFlags

class GroupAuthorityFlags

GroupId

@Serializable

data class GroupId(var blockchain: ChainSelector, var data: ByteArray) : BCHserializable

GroupInfo

@Serializable

data class GroupInfo(var groupId: GroupId, var tokenAmt: Long, var authorityFlags: ULong = 0.toULong())

Decoded data about a group that is stored in transactions outputs

Guid

class Guid(var data: Hash256 = Hash256()) : BCHserializable

Hash256

@Serializable

data class Hash256(val hash: ByteArray = ByteArray(32, { _ -> 0 })) : BCHserializable

HeadersNotForthcoming

open class HeadersNotForthcoming(val blockHash: Hash256) : BlockchainException

iBlock

interface iBlock : iBlockHeader

iBlockHeader

interface iBlockHeader : BCHserializable

IdentityDomain

class IdentityDomain(var domain: String, var useIdentity: Long) : BCHserializable

IdentityInfo

data class IdentityInfo(var identityKey: String = COMMON_IDENTITY_SEED) : BCHserializable

iLogging

interface iLogging

iMerkleBlock

interface iMerkleBlock : iBlockHeader

Initialiser

class Initialiser : Initializer<Unit>

InteractiveMultisigDestination

class InteractiveMultisigDestination(chain: ChainSelector, var convoSecret: ByteArray, var minSigs: Int, var pubkeys: Array<Bytes>, var privkeys: Array<Secret?>, var comms: ProtocolCommunication) : Pay2TemplateDestination

InUseException

open class InUseException(msg: String, val shortMsg: String? = null) : LibNexaException

Inv

class Inv(var type: Inv.Types = Types.ILLEGAL, var id: Hash256 = Hash256.ZERO) : BCHserializable

IpPort

data class IpPort(val ip: String, val port: Int, val resolutionNeeded: Boolean = false)

Helper class to pass around ip and port pairs If resolutionNeeded is true, the system will use a nslookup to resolve this to ip addresses, and return a random one (if the domain is a seeder that returns multiple choices) when resolve is called

iTcpSocket

interface iTcpSocket

iTransaction

interface iTransaction : BCHserializable

iTxInput

interface iTxInput : BCHserializable

defines what UTXOs are being spent and proves ability to spend

iTxOutpoint

interface iTxOutpoint : BCHserializable

Reference to a UTXO

iTxOutput

interface iTxOutput : BCHserializable

defines new UTXOs

JsonRpc

open class JsonRpc(val name: String, val port: Int, val logName: String = name + ":" + port, val useSSL: Boolean = false, connectTimeoutMs: Long = JsonRpc.CONNECT_TIMEOUT, accessTimeoutMs: Long = JsonRpc.ACCESS_TIMEOUT)

Open a JsonRpc communications channel with another node.

JvmLogging

class JvmLogging(val module: String) : iLogging

KvpDatabase

interface KvpDatabase

LibNexa

@ExperimentalUnsignedTypes

interface LibNexa

LibNexaException

open class LibNexaException(msg: String, val shortMsg: String? = null, val severity: ErrorSeverity = ErrorSeverity.Abnormal, val errCode: Int = -1) : Exception

LowestByteArray

class LowestByteArray : Comparator<ByteArray?>

MockAndroidLogging

class MockAndroidLogging(val module: String) : iLogging

MultiNodeCnxnMgr

class MultiNodeCnxnMgr(val name: String, netType: ChainSelector, seed: Array<IpPort>) : CommonCnxnMgr

A connection manager that handles connections to multiple nodes

MultisigDestination

class MultisigDestination(chain: ChainSelector, val minSigs: Int, val pubkeys: Array<Bytes>, val privkeys: Array<Secret?>) : Pay2TemplateDestination

MultisigP2SHDestination

class MultisigP2SHDestination(chain: ChainSelector, val minSigs: Int, val pubkeys: Array<ByteArray>, val privkeys: Array<Secret?>, index: Long) : Pay2ScriptHashDestination

MultisigSpendingProposal

class MultisigSpendingProposal(val tx: iTransaction, val dest: InteractiveMultisigDestination, val input: Int, val onAccept: SpendingProposal.() -> Unit) : SpendAnInput

NativeIosLogging

class NativeIosLogging(val module: String)

NativeLinuxLogging

class NativeLinuxLogging(val module: String) : iLogging

NativeMacosLogging

class NativeMacosLogging(val module: String)

NetException

open class NetException(msg: String) : Exception

NetMsgType

enum NetMsgType : Enum<NetMsgType>

NetMsgTypeCodingError

open class NetMsgTypeCodingError(msg: String) : P2PException

NetTimeoutException

open class NetTimeoutException(msg: String) : NetException

NEW_WALLET

object NEW_WALLET : WalletStartup

NexaBlock

class NexaBlock(val chainSelector: ChainSelector) : NexaBlockHeader, iBlock

NexaBlockHeader

open class NexaBlockHeader : CommonBlockHeader

Header of a block for Nexa

NexaBlockHeaderDb

class NexaBlockHeaderDb(val name: String, val sql: SqlDriver) : BlockHeaderDatabase

NexaMerkleBlock

class NexaMerkleBlock(val chainSelector: ChainSelector) : NexaBlockHeader, iMerkleBlock

A block that contains a subset of the total number of transactions, and includes a merkle proof that the provided transactions are part of the block

NexaSigHashType

class NexaSigHashType

Construct a Nexa-style sighash type byte array

NexaTransaction

class NexaTransaction(val chainSelector: ChainSelector) : iTransaction

blockchain transaction

NexaTxInput

class NexaTxInput(val chainSelector: ChainSelector) : iTxInput

Spend a coin (aka UTXO, prevout) in a transaction

NexaTxOutpoint

data class NexaTxOutpoint(val hash: Hash256) : iTxOutpoint

NexaTxOutput

class NexaTxOutput(val chainSelector: ChainSelector) : iTxOutput

Output of a bitcoin transaction

NodeServices

class NodeServices

NoProtocolCommunication

class NoProtocolCommunication : ProtocolCommunication

Nvh

data class Nvh(val name: String, val value: Any?, val help: String)

Objectify

class Objectify<T>(var obj: T)

Make some type (probably a primitive type) into an object that holds one of them

@Serializable

class OP(val v: ByteArray)

P2pClient

class P2pClient(val chainSelector: ChainSelector, val name: String, val port: Int, val logName: String, val coCtxt: CoroutineContext, val jobPool: ThreadJobPool = libNexaJobPool)

P2PDisconnectedException

open class P2PDisconnectedException(msg: String) : P2PException

P2PException

open class P2PException(msg: String) : NetException

P2PNoNodesException

open class P2PNoNodesException : P2PException

Pay2PubKeyHashDestination

class Pay2PubKeyHashDestination(val chainSelector: ChainSelector, var secret: Secret, idx: Long) : PayDestination

Represents a "standard" P2PKH payment destination

Pay2PubKeyTemplateDestination

class Pay2PubKeyTemplateDestination(val chainSelector: ChainSelector, var secret: Secret, idx: Long) : PayDestination

Represents a "standard" P2PKT payment destination

Pay2ScriptHashDestination

open class Pay2ScriptHashDestination(val chainSelector: ChainSelector, idx: Long) : PayDestination

Represents an arbitrary P2SH destination

Pay2ScriptPubKeyDestination

class Pay2ScriptPubKeyDestination(val chainSelector: ChainSelector, val secret: Secret, idx: Long) : PayDestination

Represents a P2PK (pay to public key) destination wrapped in a P2SH script

Pay2TemplateDestination

open class Pay2TemplateDestination(chain: ChainSelector) : PayDestination

PayAddress

data class PayAddress(var blockchain: ChainSelector, var type: PayAddressType, var data: ByteArray) : BCHserializable

PayAddressBlankException

open class PayAddressBlankException(msg: String) : PayAddressException

PayAddressDecodeException

open class PayAddressDecodeException(msg: String) : PayAddressException

PayAddressException

open class PayAddressException(msg: String, val shortMsg: String? = null, val severity: ErrorSeverity = ErrorSeverity.Expected) : LibNexaException

PayAddressType

enum PayAddressType : Enum<PayAddressType>

PayDestination

abstract class PayDestination(val chainSelector: ChainSelector) : BCHserializable

A destination for payments. This includes all the information needed to send and spend from this destination. It is often assumed that Bitcoin addresses are payment destinations, but this is not true. You really need an output script, and also (if P2SH) a redeem script. The reason why P2PKH addresses "work" as payment destinations is because they imply a specific script. But "baking in" this assumption will make the wallet a lot less flexible.

PBEKeySpecCommon

class PBEKeySpecCommon

Pbkdf2Sha512

object Pbkdf2Sha512

This is a clean-room implementation of PBKDF2 using RFC 2898 as a reference.

Periodically

class Periodically(var periodInMs: Long)

keep track of when something can happen, if there's a minimum time interval where it should happen

PermissionDeniedException

open class PermissionDeniedException(msg: String, val shortMsg: String? = null) : LibNexaException

PossibleConnection

class PossibleConnection : BCHserializable

This class tracks possible blockchain nodes -- we have learned about this node from some source but the data may not be accurate

ProtocolCommunication

interface ProtocolCommunication

ReceivedMessage

class ReceivedMessage(cmd: ByteArray, dat: ByteArray)

RejectInfo

data class RejectInfo(val command: String, val code: Int, val msg: String, val objHash: Hash256)

RequestedPrehistoryHeader

open class RequestedPrehistoryHeader(val blockHash: Hash256, val lastBlock: iBlockHeader?) : HeadersNotForthcoming

RequestMgr

class RequestMgr(val net: CnxnMgr, val genesisBlockHash: Hash256)

RetryExceeded

open class RetryExceeded : LibNexaException

SatoshiScript

open class SatoshiScript(val chainSelector: ChainSelector) : BCHserializable

A script the can be run in Nexa or BCH transaction validation virtual machine

ScriptException

open class ScriptException(msg: String, val shortMsg: String? = null, val severity: ErrorSeverity = ErrorSeverity.Abnormal) : LibNexaException

ScriptTemplate

data class ScriptTemplate(var groupInfo: GroupInfo?, val templateHash: ByteArray?, val wellKnownId: Long?, val argsHash: ByteArray?, val rest: List<ByteArray>)

Secret

abstract class Secret

SecretKeyCommon

class SecretKeyCommon(val encoded: ByteArray)

SecretKeyFactoryCommon

class SecretKeyFactoryCommon

SerializationType

enum SerializationType : Enum<SerializationType>

SocketAddress

class SocketAddress(val addr: String)

SocketOptions

class SocketOptions(var noDelay: Boolean, var receiveBufferSize: Int, var sendBufferSize: Int, var timeout: Int = 3000, var tls: Boolean = false, var keepalive: Boolean = false)

Spendable

class Spendable(var chainSelector: ChainSelector) : BCHserializable

This represents something that can be spent. It may not be spendable by ME, in which case the secret and perhaps other items will be unknown

SpendAnInput

open class SpendAnInput(val tx: iTransaction, val destination: PayDestination, val input: Int, val onAccept: SpendingProposal.() -> Unit) : SpendingProposal

SpendingProposal

abstract class SpendingProposal(val onAccept: SpendingProposal.() -> Unit)

SqldelightKvDb

class SqldelightKvDb(val name: String, val sql: SqlDriver) : KvpDatabase

SqldelightKvpDatabase

class SqldelightKvpDatabase(val name: String, val sql: SqlDriver) : KvpDatabase

SqldelightTxDatabase

class SqldelightTxDatabase(val name: String, val sql: SqlDriver) : TxDatabase

SqldelightTxoDatabase

class SqldelightTxoDatabase(val name: String, val sql: SqlDriver) : TxoDatabase

SqldelightWalletDatabase

class SqldelightWalletDatabase(val name: String, val drvr: SqlDriver, chainSelector: ChainSelector? = null) : WalletDatabase

StringJoiner

open class StringJoiner(delimiter: String)

TcpSocketChoice

enum TcpSocketChoice : Enum<TcpSocketChoice>

TcpSocketJvm

class TcpSocketJvm : iTcpSocket

TokenDesc

@Serializable

data class TokenDesc(val ticker: String, val name: String? = null, val summary: String? = null, val description: String? = null, val legal: String? = null, val creator: String? = null, val category: String? = null, val contact: Map<String, String>? = null, val icon: String? = null, val nftId: String? = null, val nftUrl: String? = null, var signedSlice: ByteArray? = null, var tddHash: ByteArray? = null, var tddSig: ByteArray? = null, var tddAddr: String? = null, var pubkey: ByteArray? = null, var marketUri: String? = null, var genesisInfo: TokenGenesisInfo? = null) : BCHserializable

TokenGenesisInfo

@Serializable

data class TokenGenesisInfo(val document_hash: String?, val document_url: String?, val height: Long, val name: String?, val ticker: String?, val token_id_hex: String, val txid: String, val txidem: String, val decimal_places: Int? = null, val op_return: String? = null) : BCHserializable

TransactionException

open class TransactionException(msg: String) : LibNexaException

TransactionHistory

class TransactionHistory(var chainSelector: ChainSelector, var tx: iTransaction) : BCHserializable

TxCompletionFlags

class TxCompletionFlags

Let's be blunt: Kotlin enums are unusable

TxDatabase

interface TxDatabase

TxoDatabase

interface TxoDatabase

TxSpendingProposal

open class TxSpendingProposal(val wallet: Wallet, val tx: iTransaction, val info: String, _mine: Boolean, val onAccept: SpendingProposal.() -> Unit) : SpendingProposal

TxValInputMetadata

@Serializable

data class TxValInputMetadata(val amount: String, val constraint: String, val constraintType: String, val outpoint: String, val satisfier: String, val sequence: String, val spentAmount: String)

TxValInputs

@Serializable

data class TxValInputs(val isValid: Boolean, val metadata: TxValInputMetadata, val errors: List<String>)

TxValInputsFlags

@Serializable

data class TxValInputsFlags(val isValid: Boolean, val inputs: List<TxValInputs>)

TxValMetadata

@Serializable

data class TxValMetadata(val size: Long? = null, val txfee: Long? = null, val txfeeneeded: Long? = null)

TxValReply

@Serializable

data class TxValReply(val txid: String, val isValid: Boolean, val isMineable: Boolean, val isFutureMineable: Boolean, val isStandard: Boolean, val metadata: TxValMetadata, val errors: List<String>, val inputs_flags: TxValInputsFlags, val inputs_mandatoryFlags: TxValInputsFlags)

UnimplementedException

open class UnimplementedException(msg: String, val shortMsg: String? = null) : LibNexaException

Units

enum Units : Enum<Units>

UnknownBlockchainException

open class UnknownBlockchainException : LibNexaException

UnknownHostException

open class UnknownHostException(msg: String) : Exception

UnsecuredSecret

class UnsecuredSecret(secretBytes: ByteArray) : Secret

UnsupportedInBlockchain

open class UnsupportedInBlockchain(msg: String) : ScriptException

variableSized

class variableSized(val data: ByteArray)

This class behaves like a function and its sole purpose is to wrap a bytearray into another class so that when we serialize it we know to include the length

Wallet

abstract class Wallet(val chainSelector: ChainSelector)

This class defines a wallet interface. A wallet is a set of payment destinations that are being tracked on a particular blockchain.

WalletAddressMissingException

open class WalletAddressMissingException(msg: String) : WalletException

WalletAuthorityException

open class WalletAuthorityException(msg: String, val severity: ErrorSeverity = ErrorSeverity.Abnormal) : WalletException

WalletDatabase

interface WalletDatabase

WalletDisconnectedException

open class WalletDisconnectedException : WalletException

WalletDustException

open class WalletDustException(msg: String) : WalletException

WalletException

open class WalletException(msg: String, val shortMsg: String? = null, val severity: ErrorSeverity = ErrorSeverity.Abnormal) : LibNexaException

WalletFeeException

open class WalletFeeException(msg: String, val severity: ErrorSeverity = ErrorSeverity.Abnormal) : WalletException

WalletImplementationException

open class WalletImplementationException(msg: String) : WalletException

WalletIncompatibleAddress

open class WalletIncompatibleAddress(msg: String) : WalletException

WalletNeedsConsolidation

open class WalletNeedsConsolidation(msg: String) : WalletException

WalletNotEnoughBalanceException

open class WalletNotEnoughBalanceException(msg: String) : WalletException

WalletNotEnoughTokenBalanceException

open class WalletNotEnoughTokenBalanceException(msg: String) : WalletException

WalletNotSupportedException

open class WalletNotSupportedException(msg: String) : WalletException

WalletStartup

sealed class WalletStartup

WallyLogFormat

class WallyLogFormat : Formatter

Properties

AES256_BLOCKSIZE

const val AES256_BLOCKSIZE: Int = 16

aes256ivCount

var aes256ivCount: Long

ANCESTOR_HASH_IF_ODD

const val ANCESTOR_HASH_IF_ODD: Int = 5040

androidContext

var androidContext: Context?

appI18n

var appI18n: (Int) -> String

change this function to install your own translation routine

APPROX_P2PKH_SIG_SCRIPT_LEN

const val APPROX_P2PKH_SIG_SCRIPT_LEN: Int

backingLog

var backingLog: iLogging?

BCH_CASH_MAGIC_MAINNET

val BCH_CASH_MAGIC_MAINNET: ByteArray

BCH_CASH_MAGIC_REGTEST

val BCH_CASH_MAGIC_REGTEST: ByteArray

BCH_CASH_MAGIC_TESTNET4

val BCH_CASH_MAGIC_TESTNET4: ByteArray

BCH_SIGHASH_ALL

const val BCH_SIGHASH_ALL: Int = 65

BCH_SIGHASH_ANYONECANPAY

const val BCH_SIGHASH_ANYONECANPAY: Int = 128

BCH_SIGHASH_NONE

const val BCH_SIGHASH_NONE: Int = 66

BCH_SIGHASH_SINGLE

const val BCH_SIGHASH_SINGLE: Int = 67

BchDecimals

const val BchDecimals: Int = 8

The number of decimal places needed to express 1 satoshi in the "normal" currency units

BchFormat

val BchFormat: DecimalFormat

How to display BCH crypto unit

bchGb

val bchGb: Hash256

BCHmainnetPort

val BCHmainnetPort: Int = 8333

BCHregtest2Port

const val BCHregtest2Port: Int = 8334

bchRegTestGb

val bchRegTestGb: Hash256

BCHregtestPort

const val BCHregtestPort: Int = 18444

bchTestnetGb

val bchTestnetGb: Hash256

BCHtestnetPort

const val BCHtestnetPort: Int = 18333

BLOCK_REQ_TIMEOUT

const val BLOCK_REQ_TIMEOUT: Long

blockchainLock

var blockchainLock: iMutex

BlockchainNetMagic

val BlockchainNetMagic: Map<ChainSelector, ByteArray>

BlockchainPort

val BlockchainPort: Map<ChainSelector, Int>

blockchains

var blockchains: MutableMap<ChainSelector, Blockchain>

BU_ADDRV2_SUPPORT

val BU_ADDRV2_SUPPORT: ULong

BU_CAPD_VERSION

val BU_CAPD_VERSION: ULong

BU_INV2_SUPPORT

val BU_INV2_SUPPORT: ULong

BU_MSG_IGNORE_CHECKSUM

val BU_MSG_IGNORE_CHECKSUM: ULong

CAPD_QUERY_NOTIFY

val CAPD_QUERY_NOTIFY: Int = 128

CAPD_QUERY_NOTIFY_BY_MSG

val CAPD_QUERY_NOTIFY_BY_MSG: Int

CAPD_QUERY_TYPE_ERROR

val CAPD_QUERY_TYPE_ERROR: Int = 3

CAPD_QUERY_TYPE_MSG

val CAPD_QUERY_TYPE_MSG: Int = 1

CAPD_QUERY_TYPE_MSG_HASH

val CAPD_QUERY_TYPE_MSG_HASH: Int = 2

CapdSolvableCutoff

var CapdSolvableCutoff: BigInteger

CHAINTIP_MARKER

val CHAINTIP_MARKER: ByteArray

chainToCurrencyCode

val chainToCurrencyCode: Map<ChainSelector, String>

Convert a ChainSelector to its approx currency code at 100M units

chainToMilliCurrencyCode

val chainToMilliCurrencyCode: Map<ChainSelector, String>

Convert a ChainSelector to its currency code at 100M/1000 units

chainToURI

val chainToURI: Map<ChainSelector, String>

Convert a ChainSelector to its uri and address prefix

CHOP_SIZE

val CHOP_SIZE: Int = 8192

CLIENT_SUBVERSION

val CLIENT_SUBVERSION: String

cnxnMgrLock

var cnxnMgrLock: iMutex

cnxnMgrs

var cnxnMgrs: MutableMap<ChainSelector, CnxnMgr>

CURRENCY_0

val CURRENCY_0: BigDecimal

The decimal number 0, with the correct "currency" rounding mode CurrencyMath. Same as CURRENCY_ZERO

CURRENCY_1

val CURRENCY_1: BigDecimal

The decimal number 1, with the correct "currency" rounding mode CurrencyMath.

CURRENCY_NEG1

val CURRENCY_NEG1: BigDecimal

The decimal number -1, with the correct "currency" rounding mode CurrencyMath.

CURRENCY_ZERO

val CURRENCY_ZERO: BigDecimal

The decimal number 0, with the correct "currency" rounding mode CurrencyMath. Same as CURRENCY_0

currencyCodeToChain

val currencyCodeToChain: Map<String, ChainSelector>

Convert a uri or address prefix to a ChainSelector -- throws exception if not found

currencyDecimals

val ChainSelector.currencyDecimals: Int

CurrencyMath

val CurrencyMath: DecimalMode

Tell the system details about how we want bigdecimal math handled

CurrencyScale

const val CurrencyScale: Int = 16

How many decimal places we need to do math without creating cumulative rounding errors

CurrencySerializeFormat

val CurrencySerializeFormat: DecimalFormat

How convert BigDecimals to strings in preparation for serialization/deserialization

DEBUG

var DEBUG: Boolean

DEFAULT_BCH_SSL_ELECTRUM_PORT

const val DEFAULT_BCH_SSL_ELECTRUM_PORT: Int = 50002

DEFAULT_BCH_TCP_ELECTRUM_PORT

const val DEFAULT_BCH_TCP_ELECTRUM_PORT: Int = 50001

DEFAULT_BCHREG_TCP_ELECTRUM_PORT

const val DEFAULT_BCHREG_TCP_ELECTRUM_PORT: Int = 60401

DEFAULT_DB_PATH

var DEFAULT_DB_PATH: String

DEFAULT_GEN_ADDRESS_CHUNK_SIZE

const val DEFAULT_GEN_ADDRESS_CHUNK_SIZE: Int = 20

DEFAULT_MAX_RECENT_BLOCK_CACHE

var DEFAULT_MAX_RECENT_BLOCK_CACHE: Int

Adjust how many blocks are held in RAM

DEFAULT_MAX_RECENT_HEADER_CACHE

var DEFAULT_MAX_RECENT_HEADER_CACHE: Int

Adjust how many headers are held in RAM

DEFAULT_MAX_RECENT_MERKLE_BLOCK_CACHE

var DEFAULT_MAX_RECENT_MERKLE_BLOCK_CACHE: Int

Adjust how many merkle blocks are held in RAM

DEFAULT_MAX_RECENT_TX_CACHE

var DEFAULT_MAX_RECENT_TX_CACHE: Int

Adjust how many tx are held in RAM

DEFAULT_NEXA_SSL_ELECTRUM_PORT

const val DEFAULT_NEXA_SSL_ELECTRUM_PORT: Int = 20002

DEFAULT_NEXA_TCP_ELECTRUM_PORT

const val DEFAULT_NEXA_TCP_ELECTRUM_PORT: Int = 20001

DEFAULT_NEXAREG_TCP_ELECTRUM_PORT

const val DEFAULT_NEXAREG_TCP_ELECTRUM_PORT: Int = 30403

DEFAULT_NEXATEST_SSL_ELECTRUM_PORT

const val DEFAULT_NEXATEST_SSL_ELECTRUM_PORT: Int = 30002

DEFAULT_NEXATEST_TCP_ELECTRUM_PORT

const val DEFAULT_NEXATEST_TCP_ELECTRUM_PORT: Int = 30001

DEFAULT_STYLE

val DEFAULT_STYLE: Set<DisplayStyle>

defaultDbPrefix

var defaultDbPrefix: String

DefaultElectrumSSL

val DefaultElectrumSSL: Map<ChainSelector, Int>

DefaultElectrumTCP

val DefaultElectrumTCP: Map<ChainSelector, Int>

DesiredFeeSatPerByte

const val DesiredFeeSatPerByte: Double = 1.1

ELECTRUM_INVALID_PARAMS

const val ELECTRUM_INVALID_PARAMS: Int

ELECTRUM_REQ_TIMEOUT

const val ELECTRUM_REQ_TIMEOUT: Int = 5000

electrumCoCtxt

val electrumCoCtxt: CoroutineContext

electrumLogging

var electrumLogging: Boolean

electrumReceiveCtxt

val electrumReceiveCtxt: CoroutineContext

englishWordList

val englishWordList: Array<String>

exceptionHandler

val exceptionHandler: CoroutineExceptionHandler

EXTVERSION_VERSION

val EXTVERSION_VERSION: ULong

EXTVERSION_VERSION_CURRENT

val EXTVERSION_VERSION_CURRENT: ULong

FiatFormat

val FiatFormat: DecimalFormat

How all fiat currencies are displayed (2 decimal places)

HEADER_SIZE_BYTES

const val HEADER_SIZE_BYTES: Int = 80

HEX_CHARS

val HEX_CHARS: String

IP_ECHO_IN_VERSION

val IP_ECHO_IN_VERSION: Boolean = false

jsonRpcLifecycle

val jsonRpcLifecycle: iMutex

KEX

const val KEX: Long

launchExceptionHandler

var launchExceptionHandler: (e: Throwable) -> Boolean?

callback to notify app of any exception that happened within the coroutine launch. Return False to raise the exception, causing program abort. If null, exception is logged and ignored

libnexa

lateinit var libnexa: LibNexa

libNexaContext

var libNexaContext: CoroutineContext

Application should set this to put non-network libnexakotlin operations into their own context (for performance). network operations have their own context: @ref NetExecContext

libNexaJobPool

var libNexaJobPool: ThreadJobPool

libNexaScope

var libNexaScope: CoroutineScope

lineSeparator

expect val lineSeparator: String

Provide the line separator for this platform

actual val lineSeparator: String

LOG_SOURCE_LOC

var LOG_SOURCE_LOC: Boolean

LOG_THREAD

var LOG_THREAD: Boolean

LOG_TIME

var LOG_TIME: Boolean

MAX_BLOOM_FILTER_SIZE

val MAX_BLOOM_FILTER_SIZE: Int = 36000

Network-defined bloom filter maximum size TODO: associate this value with the blockchain

MAX_LONG_LESIGNMAG_SIZE

const val MAX_LONG_LESIGNMAG_SIZE: Int = 9

MAX_QUIET_TIME_SEC

val MAX_QUIET_TIME_SEC: Int = 120

MAX_SHOW_COLLECTION_SIZE

val MAX_SHOW_COLLECTION_SIZE: Int = 5

MAX_TX_INPUTS

const val MAX_TX_INPUTS: Int = 256

MaxFee

var MaxFee: Int

MaxFeePerByte

const val MaxFeePerByte: Double = 5.0

mBchFormat

val mBchFormat: DecimalFormat

How the mBCH crypto unit is displayed (5 optional decimal places)

merkleBlockLock

val merkleBlockLock: iMutex

MEX

const val MEX: Long

MIN_UNUSED_ADDRESSES

const val MIN_UNUSED_ADDRESSES: Int = 20

MinFeeSatPerByte

const val MinFeeSatPerByte: Double = 1.01

MultisigWakeupCount

var MultisigWakeupCount: Int

MY_CNXNS_ONLY

var MY_CNXNS_ONLY: Boolean

netExecContext

var netExecContext: CoroutineContext?

Application should set this to put network operations into their own context (for performance)

NEX

const val NEX: Long

NEXA_NET_ID

val NEXA_NET_ID: ByteArray

NEXA_TESTNET_NET_ID

val NEXA_TESTNET_NET_ID: ByteArray

NexaDecimals

const val NexaDecimals: Int = 2

The number of decimal places needed to express 1 Satoshi (or equivalent) in the units used in the GUI

nexaElectrum

val nexaElectrum: MutableList<IpPort>

add or remove elements in this list to control the servers that we use to get electrum data by default

NexaFormat

val NexaFormat: DecimalFormat

How the NEXA crypto unit is displayed (2 optional decimal places)

nexaGb

val nexaGb: Hash256

NexaInputFormat

val NexaInputFormat: DecimalFormat

How the NEX crypto is displayed in input fields (2 optional decimal places, no thousands separator)

NexaMathMode

val NexaMathMode: DecimalMode

Tell the system details about how we want bigdecimal math handled

NexaPort

const val NexaPort: Int = 7228

nexaRegTestGb

val nexaRegTestGb: Hash256

NexaRegtestPort

const val NexaRegtestPort: Int = 18444

NexaRegtestRpcPort

const val NexaRegtestRpcPort: Int = 18332

nexaTestnetElectrum

val nexaTestnetElectrum: MutableList<IpPort>

add or remove elements in this list to control the servers that we use to get electrum data by default

nexaTestnetGb

val nexaTestnetGb: Hash256

NexaTestnetPort

const val NexaTestnetPort: Int = 7230

nexidParams

val nexidParams: Array<String>

NODE_EXTVERSION

val NODE_EXTVERSION: Long

NUM_BLOCKCHAIN_PROCESSING_THREADS

const val NUM_BLOCKCHAIN_PROCESSING_THREADS: Int = 6

OWNERSHIP_CHALLENGE_VERSION_MASK

const val OWNERSHIP_CHALLENGE_VERSION_MASK: Int = 128

P2PKT_ID

val P2PKT_ID: OP

PING_QUIET_TIME_SEC

val PING_QUIET_TIME_SEC: Int = 35

PREHISTORY_SAFEFTY_FACTOR

const val PREHISTORY_SAFEFTY_FACTOR: Int

PROTOCOL_VERSION

val PROTOCOL_VERSION: Int = 80003

RbadAddress

var RbadAddress: Int

RbadCryptoCode

var RbadCryptoCode: Int

RbadTransaction

var RbadTransaction: Int

RbadWalletImplementation

var RbadWalletImplementation: Int

Rbip70NoAmount

var Rbip70NoAmount: Int

RblankAddress

var RblankAddress: Int

RblockNotForthcoming

var RblockNotForthcoming: Int

RdataMissing

var RdataMissing: Int

RdeductedFeeLargerThanSendAmount

var RdeductedFeeLargerThanSendAmount: Int

REG_TEST_ONLY

var REG_TEST_ONLY: Boolean

REGTEST_NET_ID

val REGTEST_NET_ID: ByteArray

RexcessiveFee

var RexcessiveFee: Int

Rexpired

var Rexpired: Int

RfeeExceedsFlatMax

var RfeeExceedsFlatMax: Int

RheadersNotForthcoming

var RheadersNotForthcoming: Int

RinsufficentBalance

var RinsufficentBalance: Int

RneedNonexistentAuthority

var RneedNonexistentAuthority: Int

RnoNodes

var RnoNodes: Int

RnotSupported

var RnotSupported: Int

RsendDust

var RsendDust: Int

RsendMoreThanBalance

var RsendMoreThanBalance: Int

RsendMoreTokensThanBalance

var RsendMoreTokensThanBalance: Int

RunknownCryptoCurrency

var RunknownCryptoCurrency: Int

runningTheTests

var runningTheTests: Boolean

RwalletAddressMissing

var RwalletAddressMissing: Int

RwalletAndAddressIncompatible

var RwalletAndAddressIncompatible: Int

RwalletDisconnectedFromBlockchain

var RwalletDisconnectedFromBlockchain: Int

SAT

const val SAT: Long = 1

SATperBCH

const val SATperBCH: Long

Satoshis (finest unit) per BCH unit

SATperNEX

const val SATperNEX: Long = 100

Satoshis (finest unit) per NEXA unit

SATperUBCH

const val SATperUBCH: Long = 100

Satoshis (finest unit) per microBCH unit

SimulationHostIP

val SimulationHostIP: String

spendingProposalContext

val spendingProposalContext: CloseableCoroutineDispatcher

supportsTLS

expect val supportsTLS: Boolean

Return true if this platform supports ktor TLS TCP sockets

actual val supportsTLS: Boolean = false

actual val supportsTLS: Boolean = true

actual val supportsTLS: Boolean = false

timeFormatter

val timeFormatter: DateTimeFormatter

TOKEN_DESC_VERSION

const val TOKEN_DESC_VERSION: Byte

TOKEN_GENESIS_INFO_VERSION

const val TOKEN_GENESIS_INFO_VERSION: Byte

tokenCoCtxt

val tokenCoCtxt: CoroutineContext

TX_SCRIPTLESS_INPUT_SIZE

const val TX_SCRIPTLESS_INPUT_SIZE: Int

txHashingMutex

val txHashingMutex: iMutex

uBchDecimals

const val uBchDecimals: Int = 2

The number of decimal places needed to express 1 Satoshi (or equivalent) in the units used in the GUI

uBchFormat

val uBchFormat: DecimalFormat

How the uBCH crypto unit is displayed (2 optional decimal places)

uBchMathMode

val uBchMathMode: DecimalMode

tell the system details about how we want bigdecimal math handled

UNROUTABLE_IP

val UNROUTABLE_IP: ByteArray

uriToChain

val uriToChain: Map<String, ChainSelector>

Convert a uri or address prefix to a ChainSelector -- throws exception if not found

useTcpSocketType

var useTcpSocketType: TcpSocketChoice

ZERO_BA32

val ZERO_BA32: ByteArray

Functions

addChange

fun iTransaction.addChange(wallet: Wallet, changeOverride: PayAddress? = null)

appContext

expect fun appContext(): Any?

In platforms that use an application context object (Android), return that object. This is meant to be called only in platform specific upper layers, so each platform specific code should "know" what to cast the returned Any into.

actual fun appContext(): Any?

assert

fun assert(value: Boolean, message: String = "Assertion failed")

asUnsigned

fun Byte.~~asUnsigned~~(): Int

convert this byte to an int, treating the byte as unsigned I am wrapping toUByte() because something seems broken there -- toUInt().toInt() sign extends, toUByte does not. This seems inconsistent confusing.

awaitAvailable

expect fun awaitAvailable(cnxns: Collection<iTcpSocket>, timeout: Long = Long.MAX_VALUE): Boolean

Close a connection to trigger an early wake

Bip39Checksum

fun Bip39Checksum(bytes: ByteArray): UInt

Given recovery phrase words converted to a byte array (see @Bip39WordsToBytes) calculate the bip39 checksum

Bip39InvalidWords

fun Bip39InvalidWords(words: List<String>): List<String>

Bip39WordsToBytes

fun Bip39WordsToBytes(words: Array<String>, wordList: Array<String>): Pair<ByteArray, UInt>

This is unlikely what you want to call. It does NOT produce the master private key, it inverts GenerateBip39SecretWords for checksum calculation

Bip44AddressDerivationByChain

fun Bip44AddressDerivationByChain(chainSelector: ChainSelector): Long

Return the Bip44 address number based on this blockchain

blockFor

fun blockFor(cs: ChainSelector, ser: BCHserialized): iBlock

Construct the proper derived-class block object for the passed blockchain, and initialize it from the passed serialized data

blockFromHex

fun blockFromHex(cs: ChainSelector, hex: String, serializationType: SerializationType = SerializationType.NETWORK): iBlock

Construct the proper derived-class block object for the passed blockchain, based on the passed serialized hex string

blockHeaderFor

fun blockHeaderFor(cs: ChainSelector, ser: BCHserialized): iBlockHeader

Construct the proper derived-class block header object for the passed blockchain, and initialize it from the passed serialized data

blockHeaderFromHex

fun blockHeaderFromHex(cs: ChainSelector, hex: String, serializationType: SerializationType = SerializationType.NETWORK): iBlockHeader

Construct the proper derived-class block header object for the passed blockchain, based on the passed serialized hex string

calcSig

fun calcSig(tx: iTransaction, inputIdx: Int, sigHashType: ByteArray, serializedTx: ByteArray? = null): ByteArray

Calculate the Schnorr signature of the passed transaction and input index This function does not update the transaction.

chainSelectorDbKey

fun chainSelectorDbKey(name: String): String

ChainSelectorFromAddress

fun ChainSelectorFromAddress(address: String): ChainSelector

ChainSelectorFromValue

fun ChainSelectorFromValue(v: Byte): ChainSelector

chainStateDbKey

fun chainStateDbKey(name: String, chainSelector: ChainSelector): String

chunkInto

fun Wallet.chunkInto(payAddress: PayAddress, numUtxos: Int, amt: Long, delta: Long = 100000): List<iTransaction>

This function will split the wallet's native coin so that there are numUtxos of amt satoshis. If the wallet already has some UTXOs that fit the requirements, they count. So its possible that no transactions will be created

chunkTokenInto

fun Wallet.chunkTokenInto(gid: GroupId, payAddress: PayAddress, numUtxos: Int, tokenAmt: Long = 1): List<iTransaction>

This function will split the wallet's Tokens so that there are numUtxos of amt satoshis. If the wallet already has some UTXOs that fit the requirements, they count. So its possible that no transactions will be created

cliDump

fun cliDump(obj: Any?, level: Display = Display.User, style: DisplayStyles = DEFAULT_STYLE, depth: Int = 2, indent: Int = 0): String

connectBlockchain

fun connectBlockchain(cs: ChainSelector): Blockchain

Connect to, and return an existing blockchain. Create the blockchain object and start it processing, if it does not already exist

contains

fun Int.contains(f: CapdMsg.Fields): Boolean

copyInto

fun ByteArray.copyInto(to: ByteArray, location: Int = 0): ByteArray

createDbDriver

expect fun createDbDriver(dbname: String, schema: SqlSchema<QueryResult.Value<Unit>>): SqlDriver

actual fun createDbDriver(dbname: String, schema: SqlSchema<QueryResult.Value<Unit>>): SqlDriver

CurrencyDecimal

fun CurrencyDecimal(b: BigDecimal): BigDecimal

Convert a BigDecimal of unknown math mode (rounding & precision) into one that is appropriate for currency mathematics (with lots of decimal places)

fun CurrencyDecimal(a: Int): BigDecimal

fun CurrencyDecimal(a: Long): BigDecimal

fun CurrencyDecimal(a: String): BigDecimal

Create a BigDecimal that is appropriate for currency mathematics (with lots of decimal places)

cvt

fun cvt(s: Byte): NexaTxOutput.Type

Convert a TxOutput type raw byte into a type enum

fun cvt(s: NexaTxOutput.Type): SatoshiScript.Type

Convert transaction output type into a script type (for correct annotation of the script contained in the output)

fun cvt(s: SatoshiScript.Type): NexaTxOutput.Type

Convert a script type into the type field needed for the script to be used in a transaction output

cwd

fun cwd(): String

DbgRender

fun DbgRender(obj: Hash256): String

decimalMode

fun ChainSelector.decimalMode(): DecimalMode

decodeTokenDescDoc

fun decodeTokenDescDoc(s: String, addr: PayAddress?): TokenDesc

Decode a token description document JSON file into a TokenDesc structure, the hash of the proper part of the TDD, and its signature bytes. check the signature and fill TokenDesc pubkey with the resulting pubkey if an address is provided, and the signature matches that address.

fun decodeTokenDescDoc(grpId: GroupId, s: String, tokenGenesisTx: iTransaction): TokenDesc

decodeUtf8

expect fun ByteArray.decodeUtf8(): String

Convert a byte array that contains a utf8 string into a String

actual fun ByteArray.decodeUtf8(): String

deleteDatabase

expect fun deleteDatabase(name: String): Boolean?

Path should not contain extension (will be added) & directories may be ignored if the platform places its databases in a standard location.

actual fun deleteDatabase(name: String): Boolean?

deleteWallet

fun deleteWallet(walletName: String, chainSelector: ChainSelector)

fun deleteWallet(db: WalletDatabase, walletName: String, chainSelector: ChainSelector)

Delete a wallet on disk

deNullable

fun <T : BCHserializable> BCHserialized.deNullable(Tfactory: (BCHserialized) -> T): T?

Deserialize any object that is nullable, but prepending a byte indicating whether this object is null or not. This API should only be used for DISK serialization because this nullable technique is not part of the network protocol. However, in one case we store to disk the network serialization of an object (if it exists).

denullHash

fun BCHserialized.denullHash(): Hash256?

dictify

fun dictify(obj: Any, level: Display = Display.User, depth: Int = 10, resolve: Boolean = true, help: Boolean = false, toString: Boolean = true): Any?

dictifyType

fun dictifyType(kc: KClass<out Any>, obj: Any, level: Display = Display.User, depth: Int = 10, superTypes: Boolean = true, resolve: Boolean = true, help: Boolean = false, toString: Boolean = true): FieldDict?

dust

fun dust(chain: ChainSelector): Long

Returns the minimum amount of native coins (in the finest unit) that must be in every UTXO.

ElectrumServerOn

fun ElectrumServerOn(chain: ChainSelector): IpPort

ellipsis

fun String.ellipsis(maxLen: Int): String

encodeUtf8

expect fun String.encodeUtf8(): ByteArray

Convert a string into a utf-8 encoded byte array.

actual fun String.encodeUtf8(): ByteArray

Convert a string into a utf-8 encoded byte array.

epochMilliSeconds

expect fun epochMilliSeconds(): Long

Returns milliseconds since the epoch

actual fun epochMilliSeconds(): Long

Returns milliseconds since the epoch

actual fun epochMilliSeconds(): Long

Returns milliseconds since the epoch

actual fun epochMilliSeconds(): Long

Returns milliseconds since the epoch

epochSeconds

expect fun epochSeconds(): Long

Returns seconds since the epoch

actual fun epochSeconds(): Long

Returns seconds since the epoch

actual fun epochSeconds(): Long

Returns seconds since the epoch

actual fun epochSeconds(): Long

Returns seconds since the epoch

epochToDate

expect fun epochToDate(epochSeconds: Long): String

actual fun epochToDate(epochSeconds: Long): String

formatForDisplay

fun formatForDisplay(style: DisplayStyles, indent: Int, name: String, type: String, help: String, value: String): String

formMultisig

fun formMultisig(cs: ChainSelector, requiredSigs: Int, dests: Array<Bytes>): SatoshiScript

fromDb

fun BchBlockHeader.Companion.fromDb(db: BchBlockHeaderTbl): BchBlockHeader

fun NexaBlockHeader.Companion.fromDb(db: NexaBlockHeaderTbl): NexaBlockHeader

fromHex

fun String.fromHex(): ByteArray

fromJavaBigDecimal

fun BigDecimal.Companion.fromJavaBigDecimal(bd: <Error class: unknown class>, decimalMode: DecimalMode? = null): BigDecimal

fromNullString

fun BigDecimal.Companion.fromNullString(s: String?, dm: DecimalMode = CurrencyMath): BigDecimal?

Get a BigDecimal from a string

fromString

fun BigDecimal.Companion.fromString(s: String, dm: DecimalMode): BigDecimal

Get a BigDecimal from a string

GenerateBip39SecretWords

fun GenerateBip39SecretWords(bytes: ByteArray, wordList: Array<String> = englishWordList): String

generateBip39Seed

expect fun generateBip39Seed(wordseed: String, passphrase: String, size: Int = 64): ByteArray

actual fun generateBip39Seed(wordseed: String, passphrase: String, size: Int): ByteArray

GenerateEntropy

fun GenerateEntropy(ent: Int): ByteArray

GetAncestorHeight

fun GetAncestorHeight(height: Int): Int

Calculate the ancestor height of the block at the passed height. This follows the Nexa ancestor algorithm, returning the height of the block indicated by the ancestorHash in the Nexa block header.

getApiHelp

fun getApiHelp(obj: Any, level: Display = Display.User, style: DisplayStyles = EnumSet.of(DisplayStyle.OneLine)): String?

GetBlockchain

fun GetBlockchain(chainSelector: ChainSelector, cnxnMgr: CnxnMgr, name: String? = null, start: Boolean = true, fullSync: Boolean = true, dbPrefix: String = defaultDbPrefix): Blockchain

getClassApiHelp

fun getClassApiHelp(cls: KClass<*>, level: Display = Display.User, style: DisplayStyles = EnumSet.of(DisplayStyle.OneLine)): String?

getClassApis

fun getClassApis(cls: KClass<*>, level: Display = Display.User, style: DisplayStyles = EnumSet.of(DisplayStyle.OneLine)): String?

GetCnxnMgr

fun GetCnxnMgr(chain: ChainSelector, name: String? = null, start: Boolean = true): CnxnMgr

getFilesDir

expect fun ~~getFilesDir~~(): String?

Return the directory that this application may use for its files

actual fun getFilesDir(): String?

actual fun ~~getFilesDir~~(): String?

Return the directory that this application may use for its files

GetLog

expect fun GetLog(module: String): iLogging

get the logging object for this platform

actual fun GetLog(module: String): iLogging

getTokenInfo

fun getTokenInfo(grpId: GroupId, getEc: () -> ElectrumClient, iHave: TokenDesc? = null): TokenDesc

GetWalletData

fun GetWalletData(name: String, db: WalletDatabase): Bip44WalletData

groupedFilter

fun groupedFilter(groupId: GroupId, normal: Boolean = true, authority: ULong = GroupAuthorityFlags.AUTHORITY, maskOff: ULong = 0.toULong()): (Spendable) -> Long

handleThreadException

fun handleThreadException(e: Throwable, s: String = "", caughtAt: String? = "")

identityDomainsDbKey

fun identityDomainsDbKey(name: String): String

identityInfoDbKey

fun identityInfoDbKey(name: String): String

iHaveInternet

expect fun iHaveInternet(): Boolean?

Return false if this node has no internet connection, or true if it does or null if you can't tell

actual fun iHaveInternet(): Boolean?

Return false if this node has no internet connection, or true if it does or null if you can't tell

actual fun iHaveInternet(): Boolean?

Return false if this node has no internet connection, or true if it does or null if you can't tell

actual fun iHaveInternet(): Boolean?

Return false if this node has no internet connection, or true if it does or null if you can't tell

actual fun iHaveInternet(): Boolean?

Return false if this node has no internet connection, or true if it does or null if you can't tell

initializeLibNexa

expect fun initializeLibNexa(variant: String? = ""): LibNexa

Initialize the lowest level nexa library. This function loads the .so file and calls a "native" init function.

@Synchronized

actual fun initializeLibNexa(variant: String?): LibNexa

invert

fun <K, V> Map<K, V>.invert(): Map<V, K>

Create a new map, where the keys and values are swapped

InvertLowestOne

fun InvertLowestOne(n: Int): Int

Turn the lowest '1' bit in the binary representation of a number into a '0'.

ipAsString

expect fun ipAsString(ba: ByteArray): String

given a byte array, convert it into some string form of IP address Should support ipv4 and ipv6 at a minimum

actual fun ipAsString(ba: ByteArray): String

given a byte array, convert it into some string form of IP address Should support ipv4 and ipv6 at a minimum

isLocal

fun Url.isLocal(): Boolean

isPrimitive

fun isPrimitive(obj: Any?): Boolean

join

fun MutableList<ByteArray>.join(): ByteArray

jsonify

fun List<Any?>.jsonify(): String

laterJob

fun laterJob(name: String? = null, job: () -> Unit)

laterOneJob

fun laterOneJob(name: String, job: () -> Unit)

launch

fun launch(scope: CoroutineScope? = null, fn: suspend () -> Unit?)

leSignMag

@ExperimentalUnsignedTypes

fun ByteArray.leSignMag(): Long

Decode a number from little-endian sign-magnitude format (like a Nexa script num)

fun Long.leSignMag(size: Int? = null): ByteArray

Encode in little-endian sign-magnitude format (like a Nexa script num)

LoadPayAddressType

fun LoadPayAddressType(v: Byte): PayAddressType

logThreadException

fun logThreadException(e: Throwable, s: String = "", caughtAt: String? = "")

max

fun max(a: Int, b: Int): Int

fun max(a: Long, b: Long): Long

merkleBlockFor

fun merkleBlockFor(cs: ChainSelector, ser: BCHserialized): iMerkleBlock

Construct the proper derived-class merkle block object for the passed blockchain, and initialize it from the passed serialized data

millinow

fun millinow(): Long

Return the epoch time in milliseconds

min

fun min(a: Int, b: Int): Int

fun min(a: Long, b: Long): Long

newSpendingProposalScope

fun newSpendingProposalScope(): CoroutineScope

Get a new scope to handle all coroutines related to a particular spending proposal

newWallet

fun newWallet(name: String, bc: Blockchain): Bip44Wallet

fun newWallet(name: String, cs: ChainSelector): Bip44Wallet

Create a new wallet. A HD BIP44 compliant recovery key will be automatically generated.

NexaDecimal

fun NexaDecimal(a: Int): BigDecimal

fun NexaDecimal(a: Long): BigDecimal

Create a BigDecimal that is appropriate for Nexa currency mathematics (with 2 decimal places)

NexaToSat

fun NexaToSat(a: BigDecimal): Long

fun NexaToSat(a: Long): Long

Convert Nexa unit to Satoshis

objectType

fun objectType(obj: Any, style: DisplayStyles = DEFAULT_STYLE): String

openBchDB

fun openBchDB(name: String): BlockHeaderDatabase?

openKvpDB

fun openKvpDB(name: String): KvpDatabase?

Open a plain key/value pair database for general storage

openNexaDB

fun openNexaDB(name: String): BlockHeaderDatabase?

openOrNewWallet

fun openOrNewWallet(name: String, cs: ChainSelector): Bip44Wallet

Open this wallet if it exists, or create a new HD BIP44 wallet

openWallet

fun openWallet(name: String): Bip44Wallet

Open an existing HD BIP44 wallet.

openWalletDB

fun openWalletDB(name: String, chainSelector: ChainSelector? = null): WalletDatabase?

If you are going to create a wallet DB, you must specify the chain. Otherwise its optional (will be loaded from the db)

infix fun DisplayStyles.or(s: DisplayStyles): DisplayStyles

infix fun DisplayStyles.or(e: DisplayStyle): DisplayStyles

outpointFor

fun outpointFor(cs: ChainSelector, data: ByteArray): iTxOutpoint

fun outpointFor(cs: ChainSelector, hex: String): iTxOutpoint

fun outpointFor(cs: ChainSelector, ser: BCHserialized): iTxOutpoint

Construct the proper derived-class outpoint object for the passed blockchain, based on the passed serialized bytes

fun outpointFor(cs: ChainSelector, idem: Hash256, idx: Long): iTxOutpoint

Construct the proper derived-class outpoint object for the passed blockchain, based on the transaction identifier, and output index. You must provide the proper identifier for this blockchain (e.g. use txid for BCH and txidem for Nexa).

parseTxValReply

fun parseTxValReply(s: String): TxValReply

PlatformHttpClient

expect fun PlatformHttpClient(block: HttpClientConfig<*>.() -> Unit): HttpClient

Provide the best ktor http client (engine) offered by this platform

actual fun PlatformHttpClient(block: HttpClientConfig<*>.() -> Unit): HttpClient

range

fun range(start: Int, count: Int): IntRange

readBytes

fun Url.readBytes(timeoutInMs: Number = 30000, maxReadSize: Number = 250000000, context: CoroutineContext? = null): ByteArray

This helper function reads the contents of the URL. This duplicates the API of other URL classes

readText

fun Url.readText(timeoutInMs: Number, maxReadSize: Number = 250000000, context: CoroutineContext? = null): String

load this Uri (blocking).

receive

suspend fun <T> Channel<T>.receive(timeout: Long): T?

Receive from a channel with timeout

recoverDependencyOrder

fun recoverDependencyOrder(txUnsorted: List<iTransaction>): List<iTransaction>

recoverWallet

fun recoverWallet(name: String, recoveryKey: String, bc: Blockchain): Bip44Wallet

fun recoverWallet(name: String, recoveryKey: String, cs: ChainSelector): Bip44Wallet

Create a new HD BIP44 wallet from an recovery phrase.

rem

operator fun String.rem(kv: Map<String, String>): String

removeByValue

fun <K, V> MutableMap<K, V>.removeByValue(value: V): Int

resolveDomain

expect fun resolveDomain(domainName: String, port: Int? = null): List<ByteArray>

convert a domain name into an address

actual fun resolveDomain(domainName: String, port: Int?): List<ByteArray>

retry

fun <T> retry(count: Int, fn: (Int) -> T?): T

retryOnException

fun <T> retryOnException(count: Int, sleep: Int = 10, fn: () -> T): T

returnSpendingProposalScope

fun returnSpendingProposalScope(cs: CoroutineScope)

SatToNexa

fun SatToNexa(a: Long): BigDecimal

Convert Satoshi unit to Nexa

scriptDataFrom

fun scriptDataFrom(scriptBytes: ByteArray): ByteArray?

Parse out the data that would be pushed to the script stack from a byte array that corresponds to a script instruction.

scriptNumFrom

fun scriptNumFrom(scriptBytes: ByteArray): Long?

Parse out a script num from a byte array that corresponds to a script instruction pushing it to the script's stack

shouldDisplay

fun shouldDisplay(obj: <Error class: unknown class>, level: Display): Boolean

show

expect fun show(p: KProperty1<*, *>, obj: Any): String

Show a particular property of an object (internal CLI API)

actual fun show(p: KProperty1<*, *>, obj: Any): String

show

fun <K, V> MutableMap<K, V>.show(level: Display = Display.User, style: DisplayStyles = DEFAULT_STYLE, indent: Int = 0): String?

showAny

fun showAny(obj: Any?, indent: Int, maxString: Int, delimiter: String = "", dispValue: (String) -> String = {it}, dispHelp: (String) -> String = { " (" + it + ")" }): String

showApis

expect fun showApis(obj: Any, level: Display = Display.User, style: DisplayStyles = setOf(DisplayStyle.OneLine)): String?

actual fun showApis(obj: Any, level: Display, style: DisplayStyles): String?

showFunction

fun showFunction(fn: KFunction<*>, level: Display = Display.User, style: DisplayStyles = DEFAULT_STYLE, indent: Int = 0): Pair<String?, String>

showHelp

fun showHelp(s: String?, style: DisplayStyles, indent: Int, helpIdentifier: String = ""): String

Shows or doesn't show the help and formats it depending on the display style

showObject

expect fun showObject(obj: Any, level: Display = Display.User, style: DisplayStyles = DEFAULT_STYLE, depth: Int = 0, indent: Int = 0, maxString: Int = 300): String

Show the an object (internal CLI API)

actual fun showObject(obj: Any, level: Display, style: DisplayStyles, depth: Int, indent: Int, maxString: Int): String

showProperties

expect fun showProperties(obj: Any, cls: KClass<*>, level: Display, style: DisplayStyles, depth: Int = 0, indent: Int = 0): String

Show the properties of an object (internal CLI API)

actual fun showProperties(obj: Any, cls: KClass<*>, level: Display, style: DisplayStyles, depth: Int, indent: Int): String

showPropertyOf

fun showPropertyOf(obj: Any, p: KProperty1<*, *>, level: Display, style: DisplayStyles, depth: Int, indent: Int): String

showType

fun showType(typeName: String?, style: DisplayStyles = DEFAULT_STYLE): String

signInput

fun signInput(tx: iTransaction, idx: Long, sigHashType: ByteArray, serializedTx: ByteArray? = null): Boolean

Sign (and create the satisfier script for) one input of the passed transaction This function modifies the transaction.

signTransaction

fun signTransaction(tx: iTransaction, sigHashType: ByteArray = byteArrayOf())

signs a transaction in place, with all inputs that have a BCHspendable with secrets (skips those that do not so others can sign) by default the sighashtype is ALL/ALL

sourceLoc

expect fun sourceLoc(depth: Int = 1): String

Return the source location of the caller (for debugging and logging)

actual fun sourceLoc(depth: Int): String

splitIpPort

fun splitIpPort(s: String, defaultPort: Int): IpPort

split a (IP or FQDN):port formatted string (e.g 192.168.100.10:54 or www.example.com:54) into a string IP address (or FQDN) and an integer port

synchronized

fun <T> synchronized(g: iGate, block: () -> T): T

TcpSocket

expect fun TcpSocket(sendCtxt: CoroutineContext, receiveCtxt: CoroutineContext): iTcpSocket

actual fun TcpSocket(sendCtxt: CoroutineContext, receiveCtxt: CoroutineContext): iTcpSocket

thUpsert

fun TransactionWithoutReturn.thUpsert(db: WalletDb, idem: ByteArray, h: TransactionHistory)

toByteArray

fun String.toByteArray(): ByteArray

toCurrency

expect fun String.toCurrency(chainSelector: ChainSelector? = null): BigDecimal

Get this string as a BigDecimal currency value (using your default locale's number representation)

actual fun String.toCurrency(chainSelector: ChainSelector?): BigDecimal

toDouble

fun BigDecimal.toDouble(): Double

Convert a BigDecimal to a double

toHex

fun ByteArray.toHex(): String

@ExperimentalUnsignedTypes

fun UByteArray.toHex(): String

fun List<Byte>.toHex(): String

toInt

fun BigDecimal.toInt(): Int

Convert a BigDecimal to an int

fun Boolean.toInt(): Int

tokenizeScriptBin

fun tokenizeScriptBin(scriptBytes: ByteArray): MutableList<ByteArray>

tokenizeScriptBin is the opposite of flatten in the sense that each element in data will be 1 instruction

toLong

fun BigDecimal.toLong(): Long

toPositiveInt

fun Byte.toPositiveInt(): Int

convert this byte to an Int, treating the byte as unsigned

toPositiveLong

fun Byte.toPositiveLong(): Long

convert this byte to a Long, treating the byte as unsigned

toPositiveUInt

fun Byte.toPositiveUInt(): UInt

convert this byte to an unsigned Int, treating the byte as unsigned

toPositiveULong

fun Byte.toPositiveULong(): ULong

convert this byte to an unsigned Long, treating the byte as unsigned

toSizedByteArray

fun BigInteger.toSizedByteArray(sz: Int): ByteArray

toString

fun Long.toString(u: Units): String

toStringU

fun Int.toStringU(u: Units): String

toUint

fun Byte.~~toUint~~(): Int

txAddrGenChunkDbKey

fun txAddrGenChunkDbKey(name: String): String

txFor

fun txFor(cs: ChainSelector): iTransaction

Construct the proper derived-class transaction object for the passed blockchain

fun txFor(cs: ChainSelector, hex: String): iTransaction

fun txFor(cs: ChainSelector, ser: BCHserialized): iTransaction

Construct the proper derived-class transaction object for the passed blockchain, based on the passed serialized bytes

txFromHex

fun txFromHex(cs: ChainSelector, hex: String, serializationType: SerializationType = SerializationType.NETWORK): iTransaction

Construct the proper derived-class transaction object for the passed blockchain, based on the passed serialized hex string

txHistoryCacheDbKey

fun txHistoryCacheDbKey(name: String): String

txInputFor

fun txInputFor(cs: ChainSelector): iTxInput

Construct the proper derived-class transaction input object for the passed blockchain. This object is created with default values that then need to be set to an actual input for use.

fun txInputFor(s: Spendable): iTxInput

Construct the proper derived-class transaction input object for the passed blockchain, for the passed Spendable object. This does not solve the input (create a valid input script), since that would require the complete transaction.

txoCacheDbKey

fun txoCacheDbKey(name: String): String

txOutputFor

fun txOutputFor(cs: ChainSelector): iTxOutput

Construct the proper derived-class transaction output object for the passed blockchain This object is created with default values that then need to be set to an actual output for use.

fun txOutputFor(cs: ChainSelector, ser: BCHserialized): iTxOutput

Construct the proper derived-class transaction output object for the passed blockchain, and initialize it from the passed serialized data