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.")
        }
    }

}

Types

AccountSearchResults

data class AccountSearchResults(val status: AccountSearchResultsStatus, val details: String, val txh: MutableMap<Hash256, TransactionHistory>, val addresses: Set<PayDestination>, val addrCount: Long, val lastAddressIndex: Int, val balance: Long, val lastHeight: Long, val lastDate: Long, val lastHash: Hash256)

AccountSearchResultsStatus

enum AccountSearchResultsStatus : Enum<AccountSearchResultsStatus>

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? = null)

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

BlockchainNotSupportedException

open class BlockchainNotSupportedException(msg: String) : WalletException

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

BlockOnFork

open class BlockOnFork(val blockHash: Hash256) : BlockNotForthcoming

BloomFlags

enum BloomFlags : Enum<BloomFlags>

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

ByteArrayPrefixMap

class ByteArrayPrefixMap<V>

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

data 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.

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

ContiguousSequenceTracker

class ContiguousSequenceTracker

This class accepts insertions of integers in a random order and tracks the maximum sequence of contiguous integers that has been provided. You must not provide the same integer multiple times. An example use is async parallel requests for an indexed resource, and then filtering the responses for N in a row that have some property

CoOpTracker

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

CUtxo

class CUtxo(val cs: ChainSelector, var outpoint: iTxOutpoint, var txOut: iTxOutput, var height: Long, var inTxPool: Boolean, var spent: Boolean, var exists: Boolean) : BCHserializable

Full node sends this back in response to an info request about UTXOs

DataMissingException

open class DataMissingException(msg: String) : LibNexaException

DecimalFormat

expect class DecimalFormat(fmtSpec: String)

actual class DecimalFormat(fmtSpec: String)

actual class DecimalFormat(val fmtSpec: String)

DerivationPathSearchProgress

data class DerivationPathSearchProgress(var aborter: Objectify<Boolean>, var progress: String?, var progressInt: Int, var results: AccountSearchResults? = null)

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>

EarlyExitException

open class EarlyExitException : LibNexaException

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, val 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

EmptySecret

object EmptySecret : Secret

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

ExtInv

class ExtInv(var type: InvTypes = InvTypes.ILLEGAL, var id: ByteArray = byteArrayOf()) : BCHserializable

Extended inventory object -- uses a variable sized byte array is the identifier rather than the constant 32 bytes of Inv

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

GroupIdFlags

enum GroupIdFlags : Enum<GroupIdFlags>

GroupInfo

@Serializable

data class GroupInfo(var groupId: GroupId, var tokenAmount: 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

IncomingMsg

data class IncomingMsg(val cookie: Long, val msg: BCHserialized)

Initialiser

class Initialiser : Initializer<Unit>

InUseException

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

Inv

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

InvTypes

enum InvTypes : Enum<InvTypes>

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, val 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?>

MatchFilter

open class MatchFilter<T>(val hash: (ByteArray) -> T)

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

NativeLibLoader

object NativeLibLoader

NativeLinuxLogging

class NativeLinuxLogging(val module: String) : iLogging

NetException

open class NetException(msg: String) : Exception

NetMsgType

enum NetMsgType : Enum<NetMsgType>

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

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 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, _secret: Secret, idx: Long) : PayDestination

Represents a "standard" P2PKH payment destination

Pay2PubKeyTemplateDestination

class Pay2PubKeyTemplateDestination(val chainSelector: ChainSelector, _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, _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

PubkeyType

enum PubkeyType : Enum<PubkeyType>

Identify what type of public key is needed

ReceivedMessage

class ReceivedMessage(cmd: ByteArray, dat: ByteArray)

RejectInfo

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

RejectMsgCodes

class RejectMsgCodes

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

ScriptMatchFilter

class ScriptMatchFilter<T>(hash: (ByteArray) -> T) : MatchFilter<T>

ScriptTemplate

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

A parsed script template locking script

SearchDerivationPathActivity

class SearchDerivationPathActivity(val chainSelector: ChainSelector, val getEc: () -> ElectrumClient, val getBalance: Boolean, val ongoingResults: (AccountSearchResults) -> Unit? = null)

Secret

abstract class Secret

SecretKeyCommon

class SecretKeyCommon(val encoded: ByteArray)

SecretKeyFactoryCommon

class SecretKeyFactoryCommon

SecretTypeVer

enum SecretTypeVer : Enum<SecretTypeVer>

This enum captures both secret types and versions. When you create a new version of a certain type of secret, create a new enum, and have your class handle multiple enum values converting the old to the new format.

SecuredSecret

class SecuredSecret(index: Int, encryptedSecretBytes: ByteArray, val pubkeySecp256k1: ByteArray, var decrypt: (encryptedSecret: ByteArray, idx: Int) -> ByteArray? = null) : Secret

A secured secret holds some encrypted data, and a public value that is used to initialize the encryption. It also must be provided with a function to be used to decrypt the secret. That function may throw a WalletLockedException if it cannot decrypt the secret at this time.

SecuredSecretBytes

class SecuredSecretBytes(encryptedSecretBytes: ByteArray, val publicData: ByteArray, var decrypt: (encryptedSecret: ByteArray) -> ByteArray? = null) : Secret

SerializationType

enum SerializationType : Enum<SerializationType>

Signaler

class Signaler<T>(var signal: T, val gate: iGate = Gate())

Pass this into a blocking routing to provide the ability to wake up the routine (typically to abort it)

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 reason: String, val onAccept: suspend SpendingProposal.() -> Unit) : SpendingProposal

SpendingProposal

abstract class SpendingProposal(val onAccept: suspend 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

TokenInfoMsg

class TokenInfoMsg(var groupId: ByteArray, var ticker: String, var name: String, var uri: String, var docHash: Hash256, var decimals: Int, var genesisAddress: String) : BCHserializable

Extended inventory object -- uses a variable sized byte array is the identifier rather than the constant 32 bytes of Inv

TransactionException

open class TransactionException(msg: String) : LibNexaException

TransactionHistory

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

TxCompletionFlags

class TxCompletionFlags

Flags controlling the behavior of Wallet.txCompleter

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) : NetException

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

WalletAlreadyExistsException

open class WalletAlreadyExistsException(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

WalletLockedException

open class WalletLockedException(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

WalletUnknownContractException

open class WalletUnknownContractException(msg: String) : WalletException

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: Long

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

const 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

BLOCKCHAIN_LOGGING

var BLOCKCHAIN_LOGGING: Boolean

blockchainLock

var blockchainLock: iMutex

BlockchainNetMagic

val BlockchainNetMagic: Map<ChainSelector, ByteArray>

BlockchainPort

val BlockchainPort: Map<ChainSelector, Int>

BlockchainRpcPort

val BlockchainRpcPort: 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

CAPACITY

var CAPACITY: Int

CAPD_QUERY_NOTIFY

const val CAPD_QUERY_NOTIFY: Int = 128

CAPD_QUERY_NOTIFY_BY_MSG

const val CAPD_QUERY_NOTIFY_BY_MSG: Int

CAPD_QUERY_TYPE_ERROR

const val CAPD_QUERY_TYPE_ERROR: Int = 3

CAPD_QUERY_TYPE_MSG

const val CAPD_QUERY_TYPE_MSG: Int = 1

CAPD_QUERY_TYPE_MSG_HASH

const 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 currency code of its common unit

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

CLIENT_SUBVERSION

const 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 = 75

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

DestinationDeserializer

val DestinationDeserializer: MutableMap<Int, (chain: ChainSelector, ser: BCHserialized, index: Long) -> PayDestination>

ELECTRUM_INVALID_PARAMS

const val ELECTRUM_INVALID_PARAMS: Int

ELECTRUM_NO_REPLY

const val ELECTRUM_NO_REPLY: Int = 10000

ELECTRUM_REQ_TIMEOUT

const val ELECTRUM_REQ_TIMEOUT: Int = 5000

ELECTRUM_UNKNOWN_CLIENT_EXCEPTION

const val ELECTRUM_UNKNOWN_CLIENT_EXCEPTION: Int = 10001

electrumCoCtxt

val electrumCoCtxt: CoroutineContext

electrumLogging

var electrumLogging: Boolean

electrumReceiveCtxt

val electrumReceiveCtxt: CoroutineContext

EmptyByteArray

val EmptyByteArray: ByteArray

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

const 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

actual 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

MASTER_SECRET_IV

const val MASTER_SECRET_IV: Int = 2147483632

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_FEE_OVERPAY_DUST_MULTIPLE

const val MAX_FEE_OVERPAY_DUST_MULTIPLE: Long = 3

MAX_LONG_LESIGNMAG_SIZE

const val MAX_LONG_LESIGNMAG_SIZE: Int = 9

MAX_QUIET_TIME_SEC

const val MAX_QUIET_TIME_SEC: Int = 12

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 = 100

If we fall below this many unused addresses, make more. This happens whenever the wallet "sees" an address being used by a transaction. In the situation where a foreign same-seed wallet is spending, we might miss some transactions if more than this number of addresses are used in a block. The situation occurs because tx are not committed in creation order in blocks, so if we are tracking N unused addresses, the N+1th unused address could appear in the block first, but we haven't yet started tracking it. Ofc, no money is lost, the SPV wallet just doesn't 'see' the deposit/UTXO. Set this number high enough that such a situation would be extremely unlikely. Also to avoid race conditions when installing the bloom filter and using an address, it makes sense to generate the new ones well before they are used.

MinFeeSatPerByte

const val MinFeeSatPerByte: Double = 1.01

MY_CNXNS_ONLY

var MY_CNXNS_ONLY: Boolean

NET_LOGGING

var NET_LOGGING: Boolean

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 decimal places) 21 trillion Nexa possible

nexaGb

val nexaGb: Hash256

nexaGroupId

val nexaGroupId: GroupId

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

nexaregGroupId

val nexaregGroupId: GroupId

nexaRegTestGb

val nexaRegTestGb: Hash256

NexaRegtestPort

const val NexaRegtestPort: Int = 18444

NexaRegtestRpcPort

const val NexaRegtestRpcPort: Int = 18332

NexaRpcPort

const val NexaRpcPort: Int = 7227

nexatestGroupId

val nexatestGroupId: GroupId

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

NexaTestnetRpcPort

const val NexaTestnetRpcPort: Int = 7229

nexidParams

val nexidParams: Array<String>

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_HASH

val P2PKT_HASH: ByteArray

P2PKT_ID

val P2PKT_ID: OP

PING_QUIET_TIME_SEC

const val PING_QUIET_TIME_SEC: Int = 5

PREHISTORY_SAFEFTY_FACTOR

const val PREHISTORY_SAFEFTY_FACTOR: Int

PROTOCOL_VERSION

const 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

RunknownContractException

var RunknownContractException: Int

RunknownCryptoCurrency

var RunknownCryptoCurrency: Int

runningTheTests

var runningTheTests: Boolean

RwalletAddressMissing

var RwalletAddressMissing: Int

RwalletAlreadyExistsException

var RwalletAlreadyExistsException: Int

RwalletAndAddressIncompatible

var RwalletAndAddressIncompatible: Int

RwalletDisconnectedFromBlockchain

var RwalletDisconnectedFromBlockchain: Int

RwalletLocked

var RwalletLocked: Int

RwalletNeedsConsolidation

var RwalletNeedsConsolidation: 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

SECURED_WALLET_DB_FIELD

const val SECURED_WALLET_DB_FIELD: String

SimulationHostIP

val SimulationHostIP: String

sourceLocFileFormatter

var sourceLocFileFormatter: (String, Int) -> String

Redefine this to override how source loc files are shown

spendingProposalContext

val spendingProposalContext: CloseableCoroutineDispatcher

supportsTLS

actual val supportsTLS: Boolean = true

expect val supportsTLS: Boolean

Return true if this platform supports ktor TLS TCP sockets

actual val supportsTLS: Boolean = true

TDPP_FLAG_FUND_GROUPS

const val TDPP_FLAG_FUND_GROUPS: Int = 16

TDPP protocol operation flags: You are expected to fund missing tokens

TDPP_FLAG_NOFUND

const val TDPP_FLAG_NOFUND: Int = 1

TDPP protocol operation flags: Do not fund this transaction with native coins

TDPP_FLAG_NOPOST

const val TDPP_FLAG_NOPOST: Int = 2

TDPP protocol operation flags: Do not independently post this transaction to the blockchain (it is not valid)

TDPP_FLAG_NOSHUFFLE

const val TDPP_FLAG_NOSHUFFLE: Int = 4

TDPP protocol operation flags: Do not change the order of inputs or outputs, the counterparty will reject adjustments

TDPP_FLAG_PARTIAL

const val TDPP_FLAG_PARTIAL: Int = 8

TDPP protocol operation flags: You should partially sign this transaction so that additional inputs/outputs can be added

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

WALLET_FULL_RECOVERY_CHANGE_DERIVATION_PATH_MAX_GAP

var WALLET_FULL_RECOVERY_CHANGE_DERIVATION_PATH_MAX_GAP: Int

WALLET_FULL_RECOVERY_DERIVATION_PATH_MAX_GAP

var WALLET_FULL_RECOVERY_DERIVATION_PATH_MAX_GAP: Int

WALLET_FULL_RECOVERY_NONSTD_DERIVATION_PATH_MAX_GAP

var WALLET_FULL_RECOVERY_NONSTD_DERIVATION_PATH_MAX_GAP: Int

WALLET_LOGGING

var WALLET_LOGGING: Boolean

WALLET_RECOVERY_DERIVATION_PATH_SEARCH_DEPTH

var WALLET_RECOVERY_DERIVATION_PATH_SEARCH_DEPTH: Int

WALLET_RECOVERY_IDENTITY_DERIVATION_PATH_SEARCH_DEPTH

var WALLET_RECOVERY_IDENTITY_DERIVATION_PATH_SEARCH_DEPTH: Int

WALLET_RECOVERY_NON_INCREMENTAL_ADDRESS_HEIGHT

val WALLET_RECOVERY_NON_INCREMENTAL_ADDRESS_HEIGHT: Int = 200000

ZERO_BA32

val ZERO_BA32: ByteArray

Functions

addChange

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

appContext

actual fun appContext(): Any?

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

actual fun awaitAvailable(cnxns: Collection<iTcpSocket>, timeout: Long): Boolean

Close a connection to trigger an early wake

actual fun awaitAvailable(cnxns: Collection<iTcpSocket>, timeout: Long): Boolean

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

blockchainFor

fun blockchainFor(cs: ChainSelector, initializer: Blockchain.() -> Unit? = null): Blockchain

Synonym of connectBlockchain

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

blocking2

fun <T0, T1> blocking2(timeoutMs: Long, call: ((T0?, T1?) -> Unit) -> Unit): Pair<T0?, T1?>

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, initializer: Blockchain.() -> Unit? = null): 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

contractDbKey

fun contractDbKey(name: String): String

copyInto

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

createDbDriver

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

expect fun createDbDriver(dbname: String, schema: SqlSchema<QueryResult.Value<Unit>>, latestSchemaVersion: Long, createDbIfNonexistent: Boolean = true): SqlDriver

actual fun createDbDriver(dbname: String, schema: SqlSchema<QueryResult.Value<Unit>>, latestSchemaVersion: Long, createDbIfNonexistent: Boolean): 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

databaseDirectory

actual fun databaseDirectory(): String?

expect fun databaseDirectory(): String?

return the directory where databases are placed on this platform, "" if its in the current directory (not a specific location), or null if you do not know

actual fun databaseDirectory(): String?

dbColumnExists

fun dbColumnExists(db: SqlDriver, table: String, column: String): Boolean

This function helps us identify what version a database is to run the appropriate migration

dbGetSchemaVersion

fun dbGetSchemaVersion(driver: SqlDriver): Long

DbgRender

fun DbgRender(obj: Hash256): String

dbSetSchemaVersion

fun dbSetSchemaVersion(driver: SqlDriver, version: Long)

dbTableExists

fun dbTableExists(db: SqlDriver, table: String): Boolean

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

actual fun ByteArray.decodeUtf8(): String

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

actual fun ByteArray.decodeUtf8(): String

decryptPrivateKey

fun decryptPrivateKey(ciphertext: ByteArray, keyIndex: Int, encryptionKey: Objectify<ByteArray?>): ByteArray

deleteDatabase

actual fun deleteDatabase(name: String): Boolean?

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?

deleteWalletContents

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

Delete a wallet on disk

deleteWalletFile

fun deleteWalletFile(underlyingFileName: String): Boolean

fun deleteWalletFile(walletName: String, underlyingFileName: String, chainSelector: ChainSelector): Boolean

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?

derivationPathSearch

fun derivationPathSearch(progress: DerivationPathSearchProgress, wallet: Bip44Wallet, coin: Long, account: Long, change: Boolean, idxMaxGap: Int, start: Long = 0, event: () -> Unit? = null): iThread

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

actual 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

actual fun epochMilliSeconds(): Long

expect fun epochMilliSeconds(): Long

Returns milliseconds since the epoch

actual fun epochMilliSeconds(): Long

Returns milliseconds since the epoch

epochSeconds

actual fun epochSeconds(): Long

expect 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

fastForward

fun Bip44Wallet.fastForward(displayFastForwardInfo: (String?) -> Unit): Objectify<Boolean>

Asynchronously fast forward a Bip44Wallet by searching address derivation paths using Rostrum.

fieldDbKey

fun fieldDbKey(walletName: String, itemName: String): String

formatForDisplay

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

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

Given some entropy, generate a Bip 39 secret word list, with checksum.

generateBip39Seed

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

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

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

generateEntropy

fun generateEntropy(bits: Int): ByteArray

Return a ByteArray with a lot of cryptgraphically strong random bits

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, forceCreate: Boolean = false): 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

actual fun getFilesDir(): String?

Return the directory that this application may use for its files

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

actual fun GetLog(module: String): iLogging

expect fun GetLog(module: String): iLogging

get the logging object for this platform

actual fun GetLog(module: String): iLogging

getSystemProperty

actual fun getSystemProperty(name: String): String?

expect fun getSystemProperty(name: String): String?

Access system properties or environment variables (in that order of preference)

actual fun getSystemProperty(name: String): String?

getTokenInfo

fun getTokenInfo(grpId: GroupId, getEc: () -> ElectrumClient, cnxnMgr: CnxnMgr?, 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(), contractId: ByteArray? = null): (Spendable) -> Long

Returns a predicate function that accepts a Spendable. This function returns the token amount if the BCHspendable is in the passed group and has properties based on passed flags, and is not already reserved.

handleThreadException

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

identityDomainsDbKey

fun identityDomainsDbKey(name: String): String

identityInfoDbKey

fun identityInfoDbKey(name: String): String

iHaveInternet

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

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

initializeLibNexa

@Synchronized

actual fun initializeLibNexa(variant: String?): LibNexa

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

actual fun ipAsString(ba: ByteArray): String

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

IsPushOnly

fun SatoshiScript.IsPushOnly(): Boolean

IsPushOpcode

fun OP.IsPushOpcode(): Boolean

join

fun MutableList<ByteArray>.join(): ByteArray

jsonify

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

laterJob

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

Run the provided callback within a job pool running within libnexakotlin. This job pool is serviced by between 4 and 25 threads.

laterOneJob

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

Enqueue a job to run, but do not enqueue the same job (by name) if its already in the queue. This is useful if your job handles the "latest" state anyway. For example let's say you are updating a counter and want to do something (maybe save to disk) whenever the counter 100 (flush to disk every 100 updates). Using this function, every time I increment the counter, I can check and then launch the save in a separate thread. If you just used laterJob() you might enqueue 20 saves before the first one ran and set the counter back to 0. (yes this example is contrived and there's an easy workaround) counter += 1 if (counter 100) laterOneJob("flushCheck") { save(); counter = 0 }

launch

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

Launch a coroutine within the libnexakotlin handler threads, or a scope you provide. This is a small helper function to launch a couroutine outside of the kotlin default handler (which tends to get busy), with a default exception handler that logs the exception and continues.

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

nativeCoinGroupId

fun nativeCoinGroupId(cs: ChainSelector): GroupId

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

fun NexaDecimal(a: String): 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?

openCreateDisconnectedWallet

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

Create a wallet that is not actively connected to a blockchain. This is used in applications that trust a blockchain data provider, or just for operations like signing messages. You still need to tell me what blockchain this wallet uses so it can create addresses in the proper space.

openDisconnectedWallet

fun openDisconnectedWallet(name: String): Bip44Wallet

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).

P2PKT_SCRIPT

fun P2PKT_SCRIPT(cs: ChainSelector): SatoshiScript

p2pktFromPubkey

fun p2pktFromPubkey(chainSelector: ChainSelector, pubkey: ByteArray): PayAddress

This function create a pay-to-pubkey-template address from a pubkey. This is very uncommon since it cannot be used to sign anything and typically if the address isn't yours, you would have been given the address, not the pubkey. It is used when recovering pubkeys from signed messages or from inside scripts.

parseTxValReply

fun parseTxValReply(s: String): TxValReply

PlatformHttpClient

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

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

Create a IntRange using starting number and count semantics, rather than start and end

readBytes

fun Url.readBytes(idleInMs: Number = 10000, timeoutInMs: Number = 120000, 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(idleInMs: Number = 10000, timeoutInMs: Number = 120000, maxReadSize: Number = 250000000, context: CoroutineContext? = null): String

load this Uri (blocking).

reasonableNexaEpochMs

fun reasonableNexaEpochMs(date: Long?): Boolean

Sanity check a date: returns false if before the genesis block (rounded) or after 24 hours from now.

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>

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

convert a domain name into an address

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

ResolveFromChoicesList

fun ResolveFromChoicesList(choices: MutableList<IpPort>): IpPort

retry

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

retryOnDbException

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

Retries if the exception is any transient DB access throw, but if the problem is unsolvable (typically DB closed), then throw immediately

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

SatToString

fun SatToString(a: Long): String

Convert Satoshi a Nexa-unit display string

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 if scriptBytes is an invalid push, null is returned

searchDerivationPathActivitySecret

fun searchDerivationPathActivitySecret(getEc: () -> ElectrumClient, chainSelector: ChainSelector, maxGap: Int, secretDerivation: (Int) -> Secret?, ongoingResults: (AccountSearchResults) -> Unit? = null): AccountSearchResults

SetLogFile

actual fun SetLogFile(name: String)

expect fun SetLogFile(name: String)

Sets the log location and file name (if relevant for this platform). This function should be called early in the initialization; however since GetLog() is often called to init a global variable, this set function MUST apply to all iLogging objects that have already been created. You may pass "" to stop logging on platforms that create a separate log file

actual fun SetLogFile(name: String)

shouldDisplay

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

show

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

actual 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

actual fun showObject(obj: Any, level: Display, style: DisplayStyles, depth: Int, indent: Int, maxString: Int): 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

actual fun showProperties(obj: Any, cls: KClass<*>, level: Display, style: DisplayStyles, depth: Int, indent: Int): 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

shutdownLibNexa

fun shutdownLibNexa()

Shutdown the libnexa processing threads and any other tasks needed to stop. Thread stopping occurs via join() so if you have launched an infinite loop as a libnexa job @see laterJob @see laterOneJob, this function will not return. Shutdown is permanent. After calling this function, do not call initializeLibNexa again (and expect that it will work).

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()): Int

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

actual fun sourceLoc(depth: Int): String

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(): iTcpSocket

actual fun TcpSocket(): iTcpSocket

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

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

actual fun TcpSocket(): 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

actual fun String.toCurrency(chainSelector: ChainSelector?): 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

toLeBytes

fun Int.toLeBytes(): ByteArray

fun Long.toLeBytes(): ByteArray

toLong

fun BigDecimal.toLong(): Long

fun ByteArray.toLong(): Long

Convert the first 8 bytes of a bytearray to a little endian 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 Int.toString(u: Units): String

fun Long.toString(u: Units): String

Convert an integer into a string that approximates the value in a human readable manner. For example 3200000 becomes 3mB

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(coinAmount: Long, address: PayAddress): iTxOutput

fun txOutputFor(address: PayAddress, tokenAmount: Long, tokenType: GroupId, coinAmount: Long? = null): iTxOutput

fun txOutputFor(dest: PayDestination, tokenAmount: Long, tokenType: GroupId, coinAmount: Long? = null): iTxOutput

Construct the proper derived-class transaction output object to send tokens (and some native). Only works for Nexa family.

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

fun txOutputFor(cs: ChainSelector, amount: Long, script: SatoshiScript): iTxOutput

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

txStateDbKey

fun txStateDbKey(name: String): String

uAsInt

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

UbchDecimal

fun UbchDecimal(a: Long): BigDecimal

Create a BigDecimal that is appropriate for u-BCH (micro bitcoin cash) currency mathematics (with 2 decimal places)

ufromHex

@ExperimentalUnsignedTypes

fun String.ufromHex(): UByteArray

unusedAddressesDbKey

fun unusedAddressesDbKey(name: String): String

urlDecode

actual fun String.urlDecode(): String

expect fun String.urlDecode(): String

Converts an encoded URL to a raw string

actual fun String.urlDecode(): String

urlEncode

actual fun String.urlEncode(): String

expect fun String.urlEncode(): String

actual fun String.urlEncode(): String

fun Byte.urlEncode(): String

actual fun String.urlEncode(): String

utoHex

fun List<UByte>.utoHex(): String

validBip39Checksum

fun validBip39Checksum(words: Array<String>, wordList: Array<String> = englishWordList): Boolean

Return true if the checksum stored within the recovery key words is valid

weekOfBlocks

fun weekOfBlocks(cs: ChainSelector): Int

How many blocks are found (on average) in a single week in this blockchain

writeFully

fun iTcpSocket.writeFully(str: String)