utxoninja
v0.2.54
Published
Bitcoin and Paymail Management Done Right
Downloads
39
Readme
utxoninja
Bitcoin and Paymail Management Done Right
The code is on GitHub and the package is available through NPM.
There is a web interface that wraps this library available at ninja.babbage.systems.
Refer to the Dojo API docs for additional, useful information.
With the exception of getTransactionWithOutputs
(which just automates the creation and signing of the simpler transactions), most of the functions here are just one-to-one mappings of the Dojo API endpoints themselves. HTTP, API request authentication and the parsing of responses are handled for you by this library.
To get started making transactions, you should check out getTransactionWithOutputs after funding your account
If you need help, don't hesitate to send a message to Ty Everett on the Atlantis Slack.
API
Table of Contents
- Ninja
- Parameters
- createAuthriteRequest
- getPaymail
- setPaymail
- getAvatar
- setAvatar
- getTransactions
- getPendingTransactions
- getTotalOfAmounts
- getTotalValue
- getTransactionWithOutputs
- createTransaction
- getNetwork
- processTransaction
- processPendingTransactions
- getTransactionOutputs
- updateTransactionStatus
- submitDirectTransaction
- verifyIncomingTransaction
- updateOutpointStatus
- saveCertificate
- findCertificates
- GetTxWithOutputsOutput
- GetTxWithOutputsResult
Ninja
Get Object Type Definitions
Parameters
$0
Object (optional, default{}
)$0.privateKey
$0.config
(optional, defaultCONFIG
)$0.taalApiKeys
(optional, default{test:'testnet_ba132cc4d5b2ebde7ed0ee0f6ee3f678',main:'mainnet_6c8f8c37afd5c45e09f62d083288a181'}
)
obj
Object All parameters are given in an object
createAuthriteRequest
Wraps the Authrite.request method to provide additional functionality
Parameters
feature
String The request destination routefetchConfig
Object Any configuration including the request body
Returns Object JSON object containing the result of the request
getPaymail
Returns the current Paymail handle
Returns Promise<String> The Paymail handle
setPaymail
Changes the Paymail handle of the user. NOTE that the old handle will be available for others to use. NOTE that to prevent span, you may only do this if there is at least one unspent output under Dojo management.
Parameters
Returns Promise<Object> A success object with status: "success"
getAvatar
Returns the name and photo URL of the user
Returns Promise<Avatar> The avatar of the user
setAvatar
Sets a new name and photo URL
Parameters
obj
Object All parameters are given in an object
Returns Promise<Object> A success object with status: "success"
getTransactions
Returns a set of transactions that match the criteria
Parameters
obj
Object All parameters are given in an object (optional, default{}
)obj.limit
Number Include only this maximum number of transactions in the set (optional, default25
)obj.offset
Number Include transactions offset by this number in the full set (optional, default0
)obj.involving
String? Only include transactions sent to or received from this Paymail handleobj.orderBy
String Sort order, can benewest-first
oroldest-first
(optional, defaultnewest-first
)obj.label
String? Only include transactions affixed with this labelobj.status
String? If provided, only transactions with the given status will be returnedobj.referenceNumber
Returns Promise<GetTransactionsResult> The transactions and the total size of the set
getPendingTransactions
Returns a set of all transactions that need to be signed and submitted, or canceled
Parameters
$0
Object (optional, default{}
)$0.referenceNumber
Returns Promise<Array<GetPendingTransactionsTx>> The array of pending transactions
getTotalOfAmounts
Returns the total of the amounts of transactions that fall under certain criteria
Parameters
obj
Object All parameters are given in an object (optional, default{}
)obj.involving
String? The Paymail handle of a user who must be involved with the transactionsobj.label
String? The label that must be affixed to the transactionsobj.direction
String Must be either "incoming" or "outgoing", transactions in only one direction can be totaledobj.startTime
Number? The earlies time of the transactions to include, an epoch timestamp in secondsobj.endTime
Number? The latest time of the transactions to include, an epoch timestamp in seconds
Returns Promise<Object> An object containing total
, a number of satoshis
getTotalValue
Returns the total of unspent outputs
Returns Promise<Object> An object containing total
, a non-negative number of satoshis
getTransactionWithOutputs
Creates and signs a transaction with specified outputs, so that it can be processed with processTransaction
. This is a higher-level wrapper around createTransaction
so that you do not need to manually handle signing, when you are not providing any non-Dojo inputs.
Use this by default, and fall back to createTransaction
if you need more customization.
Parameters
obj
Object All parameters are given in an object (optional, default{}
)obj.outputs
Array<GetTxWithOutputsOutput> A set of outputs to include, each withscript
andsatoshis
. (optional, default[]
)obj.feePerKb
Number The number of satoshis to pay per KB of block space used by this transaction. (optional, default110
)obj.labels
Array<String> A set of label strings to affix to the transaction (optional, default[]
)obj.inputs
Object Input scripts to spend as part of this transaction. This is an object whose keys are TXIDs and whose values are Everett-style transaction envelopes that contain an additional field calledoutputsToRedeem
. This is an array of objects, each containingindex
andunlockingScript
properties. Theindex
property is the output number in the transaction you are spending, andunlockingScript
is the hex scriptcode that unlocks the satoshis. Note that you should create any signatures withSIGHASH_NONE | ANYONECANPAY
or similar so that the additional Dojo outputs can be added afterward without invalidating your signature. (optional, default{}
)obj.autoProcess
Boolean Whether the transaction should be processed automatically with processTransaction. Note that this will returnmapiResponses
andnote
instead of referenceNumber (optional, defaulttrue
)obj.note
String? A note about the transactionobj.recipient
String? Paymail recipient for transactionobj.authriteClient
Authrite An API for invoking mutually authenticated requests
Returns Promise<GetTxWithOutputsResult> The serialized transaction, inputs, reference number and amount
createTransaction
Creates a new transaction that must be processed with processTransaction
after you sign it
Parameters
obj
Object All parameters are given in an objectobj.inputs
Object<TxInputEnvelope>? Specify any additional inputs to the transaction (if any) that are not to be provided by the Dojo. If you do not provide inputs here, or if they are insufficient, Dojo will select additional inputs for you to sign. To control this input selection behavior, see theinputSelection
parameter. Thisinputs
parameter is an object whose keys are TXIDs of input transactions, and whose values are their associated SPV envelopes.obj.inputSelection
Object? If Dojo needs to select more inputs beyond what you provided in theinputs
parameter, this parameter describes which kinds of inputs can be selected, and from where.obj.inputSelection.disable
Boolean? This is a boolean that, when true, will forbid Dojo from adding any additional inputs to your transaction, beyond what you specified in theinputs
parameter. Thus, if you have not sufficiently funded the transaction yourself, or ifinputs
is empty, you will get an error.obj.inputSelection.maxUnconfirmedChainLength
Number? An integer representing the maximum length for any chain of unconfirmed parents that a selected input can have. When -1 (the default), no maximum is specified. Cannot be zero. When 1, indicates that the input must itself be confirmed. When 2, input parents must be confirmed. 3 denotes grandparents, 4 great-grandparents and so forth.
obj.outputs
Array<TxOutput>? External outputs that you will include when you create this transaction. These outputs can contain custom scripts as specified by recipients. If the inputs to the transaction go beyond what is needed to fund these outputs (plus the transaction fee), additional Dojo-managed UTXOs will be generated to collect the remainder (see theoutputGeneration
parameter for more on this).obj.outputGeneration
Object? If Dojo needs to generate additional outputs for the transaction beyond what was specified, this object describes what kind of outputs to generate, and where they should be kept.obj.outputGeneration.method
String The method used to generate outputs. "auto" selects the amount and types of generated outputs based on the selected basket's configuration for how many of each type to keep on hand, then uses Benford's law to distribute the satoshis across them. "single" just uses one output, randomly selected from the available types, that contains all the satoshis. (optional, defaultauto
)
obj.fee
Object? Represents the fee the transaction will payobj.labels
Array<String>? The labels to affix to this transactionobj.note
String? A numan-readable note describing the transactionobj.recipient
String? The Paymail handle for the recipient of the transaction
Returns Promise<TransactionTemplate> The template you need to sign and process
getNetwork
Returns which BSV network we are using (mainnet or testnet)
Parameters
format
String for the returned string. Either with or without a 'net' suffix. (optional, default'default'
)
Returns String The current BSV network formatted as requested.
processTransaction
After a transaction is created (with createTransaction
or with getTransactionWithOutputs
) this is used to process the transaction, thereby activating any change outputs and flagging designated inputs as spent
Parameters
obj
Object All parameters are given in an objectobj.inputs
String Inputs to spend as part of this transactionobj.submittedTransaction
String The transaction that has been created and signedobj.reference
String The reference number provided bycreateTransaction
orgetTransactionWithOutputs
obj.outputMap
Object An object whose keys are derivation prefixes and whose values are corresponding change output numbers from the transaction.
Returns Promise<Object> An object containing a note
field with a success message, and mapiResponses
, for use in creating an SPV Envelope
processPendingTransactions
Signs and processes all pending transactions, useful when recovering from an error or crash, or on startup. If a transaction fails to process, marks it as failed.
Parameters
obj
Object All parameters are given in an object (optional, default{}
)
Returns Promise Resolves once the operation is complete
getTransactionOutputs
Returns a set of transaction outputs that Dojo has tracked
Parameters
obj
Object All parameters are given in an object (optional, default{}
)obj.basket
String? If provided, indicates which basket the outputs should be selected from.obj.tracked
Boolean? If provided, only outputs with the corresponding tracked value will be returned (true/false).obj.includeEnvelope
Boolean? If provided, returns a structure with the SPV envelopes for the UTXOS that have not been spent. (optional, defaultfalse
)obj.spendable
Boolean? If given as true or false, only outputs that have or have not (respectively) been spent will be returned. If not given, both spent and unspent outputs will be returned.obj.type
String? If provided, only outputs of the specified type will be returned. If not provided, outputs of all types will be returned.obj.limit
Number? Provide a limit on the number of outputs that will be returned. (optional, default25
)obj.offset
Number? Provide an offset into the list of outputs. (optional, default0
)
Returns Promise<Array<TransactionOutputDescriptor>> A set of outputs that match the criteria
updateTransactionStatus
Use this endpoint to update the status of a transaction. This is useful for flagging incomplete transactions as aborted or reverting a completed transaction back into a pending status if it never got confirmed. Setting the status to "completed" or "waitingForSenderToSend" will make any selected UTXOs unavailable for spending, while any other status value will free up the UTXOs for use in other transactions.
Parameters
obj
Object All parameters are given in an object
Returns Promise<Object> A success object with status: "success"
submitDirectTransaction
This endpoint allows a recipient to submit a transactions that was directly given to them by a sender. Saves the inputs and key derivation information, allowing the UTXOs to be redeemed in the future. Sets the transaction to completed and marks the outputs as spendable.
Parameters
obj
Object All parameters are given in an objectobj.protocol
string Specify the transaction submission payment protocol to use. Currently, the only supported protocol is that with BRFC ID "3241645161d8"obj.transaction
Object The transaction envelope to submit, including key derivation informationobj.transaction.outputs
Array An array of outputs, each containingvout
,satoshis
,derivationSuffix
, and (optionally),derivationPrefix
. If a globalderivationPrefix
is used (recommended), output-specific derivation prefixes should be omitted.
obj.senderIdentityKey
string Provide the identity key for the person who sent the transactionobj.note
string Human-readable description for the transactionobj.derivationPrefix
string? A derivation prefix used for all outputs. If provided, derivation prefixes on all outputs are optional.obj.amount
obj.labels
Returns Promise<Object> Object containing reference number, status=success, and human-readable note acknowledging the transaction
verifyIncomingTransaction
Verifies an incoming Paymail transaction (deprecated, use submitDirectTransaction)
Parameters
obj
Object
Returns Promise<Boolean> A success boolean status
updateOutpointStatus
Use this endpoint to update the status of one of your outputs, given as the TXID of a transaction and the vout (output index) in that transaction. This is useful for flagging transaction outpoints as spent if they were inadvertantly broadcasted or used without properly submitting them to the Dojo, or to undo the spending of an output if it was never actually spent.
Parameters
obj
Object All parameters are given in an object
Returns Promise<Object> A success object with status: "success"
saveCertificate
Use this endpoint to store an incoming certificate.
Parameters
obj
Object All parameters are given in an objectobj.certificate
Object The certificate object to save
Returns Promise<Object> A success object with status: "success"
findCertificates
Use this endpoint to retrieve certificates.
Parameters
obj
Object All parameters are given in an object
Returns Promise<Object> A success object with status: "success"
and any found certificates
GetTxWithOutputsOutput
Type: Object
Properties
script
String The hex representing the locking script of the outputsatoshis
Number The number of satoshis to put in the output
GetTxWithOutputsResult
Type: Object
Properties
rawTx
String The serialized, signed transaction that is ready for broadcasttxid
String The txid for the new transactionreferenceNumber
String The reference number that should now be provided back toprocessTransaction (or
updateTransactionStatus`)inputs
Object This is the fully-formedinputs
field of this transaction, as per the SPV Envelope specification.amount
Number The amount of the transaction
Handling Errors
When errors are returned from the Dojo API, they take the form of an object with three fields:
- status: Will be
error
if there is an error. - code: The machine-readable error code. Example:
ERR_BAD_THING
- description: The human-readable error message. Example:
A bad thing has happened.
The UTXONinja wrapper will raise JavaScript errors in the following format:
ERR_BAD_THING: A bad thing has happened.
You can parse these error messages into a usable format as follows:
try {
await ninja.someFunction()
} catch (e) {
console.error(`Error code: ${e.message.split(':')[0]}`)
console.error(`Error message: ${e.message.split(':')[1].trim()}`)
}
If you want custom error messages, or if you are building an internationalized (non-English) application, you can utilize the machine-readable error codes. A list of current codes can be found in the Table of Errors in the Dojo API Documentation.
License
The license for this library, which is a wrapper for the proprietary Dojo API, is the Open BSV License. It can only be used on the BSV blockchain. The Dojo API itself, including the rights to create and host Dojo servers or any other related infrastructure, is not covered by the Open BSV License and remains proprietary and restricted. The Open BSV License only extends to the code in this repository, and you are not permitted to host Dojo servers or create copies or alternative implementations of the proprietary Dojo API without other permission.