// https://github.com/RavenProject/Ravencoin/blob/master/src/rpc/rawtransaction.cpp
import { IClient } from '@/types';
import {
CombineRawTransaction,
CreateRawTransaction,
DecodeRawTransaction,
DecodeRawTransactionResponse,
DecodeScript,
DecodeScriptResponse,
GetRawTransaction,
GetRawTransactionResponse,
GetTxOutProof,
GetTxOutProofResponse,
SendRawTransaction,
SignRawTransaction,
SignRawTransactionResponse,
TestMempoolAccept,
TestMempoolAcceptResponse,
VerifyTxOutProof,
VerifyTxOutProofResponse,
} from './types';
/**
* @class RawTransactions
* @subcategory Methods
*/
export class RawTransactions {
private _client: IClient;
constructor(client: IClient) {
this._client = client;
}
/**
* @deprecated
* NOTE: By default this function only works for mempool transactions. If the -txindex option is enabled, it also works for blockchain transactions.
*
* DEPRECATED: for now, it also works for transactions with unspent outputs.
*
* Return the raw transaction data.
*
* If verbose is 'true', returns an Object with information about 'txid'.
*
* If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.
* @param params
* @param {string} params.txid The transaction id
* @param {boolean=} [params.verbose=false] If false, return a string, otherwise return a json object
* @returns {Promise<string | GetRawTransactionResponse>} The serialized, hex-encoded data for 'txid' or verbose txid
*/
getRawTransaction({
txid,
verbose,
}: GetRawTransaction): Promise<string | GetRawTransactionResponse> {
const data = [txid, verbose ?? false];
return this._client.request('getrawtransaction', data);
}
/**
* Create a transaction spending the given inputs and creating new outputs.
*
* Outputs are addresses (paired with a RVN amount, data or object specifying an asset operation) or data.
*
* Returns hex-encoded raw transaction.
*
* Note that the transaction's inputs are not signed, and it is not stored in the wallet or transmitted to the network.
*
* Paying for Asset Operations: Some operations require an amount of RVN to be sent to a burn address.
*
* Paying for Asset Operations: Some operations require an amount of RVN to be sent to a burn address:
*
* * Operation: Amount + Burn Address
* * transfer: 0
* * transferwithmessage: 0
* * issue: " + i64tostr(GetBurnAmount(AssetType::ROOT) / COIN) + " to " + GetBurnAddress(AssetType::ROOT) +
* * issue (subasset): " + i64tostr(GetBurnAmount(AssetType::SUB) / COIN) + " to " + GetBurnAddress(AssetType::SUB) +
* * issue_unique: " + i64tostr(GetBurnAmount(AssetType::UNIQUE) / COIN) + " to " + GetBurnAddress(AssetType::UNIQUE) +
* * reissue: " + i64tostr(GetBurnAmount(AssetType::REISSUE) / COIN) + " to " + GetBurnAddress(AssetType::REISSUE) +
* * issue_restricted: " + i64tostr(GetBurnAmount(AssetType::RESTRICTED) / COIN) + " to " + GetBurnAddress(AssetType::RESTRICTED) +
* * reissue_restricted: " + i64tostr(GetBurnAmount(AssetType::REISSUE) / COIN) + " to " + GetBurnAddress(AssetType::REISSUE) +
* * issue_qualifier: " + i64tostr(GetBurnAmount(AssetType::QUALIFIER) / COIN) + " to " + GetBurnAddress(AssetType::QUALIFIER) +
* * issue_qualifier (sub): " + i64tostr(GetBurnAmount(AssetType::SUB_QUALIFIER) / COIN) + " to " + GetBurnAddress(AssetType::SUB_QUALIFIER) +
* * tag_addresses: " + "0.1 to " + GetBurnAddress(AssetType::NULL_ADD_QUALIFIER) + " (per address)
* * untag_addresses: " + "0.1 to " + GetBurnAddress(AssetType::NULL_ADD_QUALIFIER) + " (per address)
* * freeze_addresses: 0
* * unfreeze_addresses: 0
* * freeze_asset: 0
* * unfreeze_asset: 0
* Assets For Authorization: These operations require a specific asset input for authorization:
* * Root Owner Token:
* * reissue
* * issue_unique
* * issue_restricted
* * reissue_restricted
* * freeze_addresses
* * unfreeze_addresses
* * freeze_asset
* * unfreeze_asset
* * Root Qualifier Token:
* * issue_qualifier (when issuing subqualifier)
* * Qualifier Token:
* * tag_addresses
* * untag_addresses
*
* Output Ordering: Asset operations require the following:
*
* 1. All coin outputs come first (including the burn output).
* 2. The owner token change output comes next (if required).
* 3. An issue, reissue, or any number of transfers comes last
* * (different types can't be mixed in a single transaction).
* @param params
* @param {Array} params.inputs
* @param {Array} params.outputs
* @param {number=} [params.locktime=0]
* @returns {Promise<string>} transaction - hex string of the transaction
*/
createRawTransaction({
inputs,
outputs,
locktime,
}: CreateRawTransaction): Promise<string> {
const data = [inputs, outputs, locktime ?? 0];
return this._client.request('createrawtransaction', data);
}
/**
* Return a JSON object representing the serialized, hex-encoded transaction.
* @param params
* @param {string} hexstring The transaction hex string
* @returns {Promise<DecodeRawTransactionResponse>} Parsed transaction
*/
decodeRawTransaction({
hexstring,
}: DecodeRawTransaction): Promise<DecodeRawTransactionResponse> {
return this._client.request('decoderawtransaction', [hexstring]);
}
/**
* Decode a hex-encoded script.
* @param params
* @param {string} params.hexstring // the hex encoded script
* @returns {Promise<DecodeScriptResponse>}
*/
decodeScript({ hexstring }: DecodeScript): Promise<DecodeScriptResponse> {
return this._client.request('decodescript', [hexstring]);
}
/**
* Submits raw transaction (serialized, hex-encoded) to local node and network.
*
* Also see createrawtransaction and signrawtransaction calls.
* @param params
* @param {string} params.hexstring The hex string of the raw transaction)
* @param {boolean=} [params.allowhighfees=false] Allow high fees
* @returns {Promise<string>} The transaction hash in hex
*/
sendRawTransaction({
hexstring,
allowhighfees,
}: SendRawTransaction): Promise<string> {
const data = [hexstring, allowhighfees ?? false];
return this._client.request('sendrawtransaction', data);
}
/**
* Combine multiple partially signed transactions into one transaction.
*
* The combined transaction may be another partially signed transaction or a fully signed transaction.
* @param params
* @param {Array} params.txs A json array of hex strings of partially signed transactions
* @returns {Promise<string>} The hex-encoded raw transaction with signature(s)
*/
combineRawTransaction({ txs }: CombineRawTransaction): Promise<string> {
return this._client.request('combinerawtransaction', [txs]);
}
/**
* Sign inputs for raw transaction (serialized, hex-encoded).
*
* The second optional argument (may be null) is an array of previous transaction outputs that this transaction depends on but may not yet be in the block chain.
*
* The third optional argument (may be null) is an array of base58-encoded private keys that, if given, will be the only keys used to sign the transaction.
* @param params
* @param {string} params.hexstring The transaction hex string
* @param {Array=} params.prevtxs Array of json objects, or 'null' if none provided
* @param {Array=} params.privkeys Array of strings, or 'null' if none provided. Private key in base58-encoding
* @param {string=} params.sighashtype 'ALL' | 'NONE' | 'SINGLE' | 'ALL|ANYONECANPAY' | 'NONE|ANYONECANPAY' | 'SINGLE|ANYONECANPAY'. Default = ALL. The signature hash type
* @returns {Promise<SignRawTransactionResponse>}
*/
signRawTransaction({
hexstring,
prevtxs,
privkeys,
sighashtype,
}: SignRawTransaction): Promise<SignRawTransactionResponse> {
const data = [
hexstring,
prevtxs ?? null,
privkeys ?? null,
sighashtype ?? 'SIGHASH_ALL',
];
return this._client.request('signrawtransaction', data);
}
/**
* Returns if raw transaction (serialized, hex-encoded) would be accepted by mempool.
*
* This checks if the transaction violates the consensus or policy rules.
*
* See sendrawtransaction call.
* @param params
* @param {Array} params.rawtxs An array of hex strings of raw transactions. Length must be one for now.
* @param {boolean=} [parasm.allowhighfees=false] Default = false. Allow high fees.
* @returns {Promise<TestMempoolAcceptResponse>} The result of the mempool acceptance test for each raw transaction in the input array. Length is exactly one for now.
*/
testMempoolAccept({
rawtxs,
allowhighfees,
}: TestMempoolAccept): Promise<TestMempoolAcceptResponse> {
const data = [rawtxs, allowhighfees ?? false];
return this._client.request('testmempoolaccept', data);
}
/**
* Returns a hex-encoded proof that \"txid\" was included in a block.
*
* NOTE: By default this function only works sometimes. This is when there is an unspent output in the utxo for this transaction. To make it always work, you need to maintain a transaction index, using the -txindex command line option or specify the block in which the transaction is included manually (by blockhash).
* @param params
* @param {Array} params.txids An array of transaction hashes
* @param {string=} params.blockhash If specified, looks for txid in the block with this hash
* @returns {Promise<GetTxOutProofResponse>} A string that is a serialized, hex-encoded data for the proof.
*/
getTxOutProof({
txids,
blockhash,
}: GetTxOutProof): Promise<GetTxOutProofResponse> {
const data: (string | string[])[] = [txids];
if (blockhash) {
data.push(blockhash);
}
return this._client.request('gettxoutproof', data);
}
/**
* Verifies that a proof points to a transaction in a block, returning the transaction it commits to and throwing an RPC error if the block is not in our best chain
* @param params
* @param {string} params.proof The hex-encoded proof generated by gettxoutproof
* @returns {Promise<VerifyTxOutProofResponse>} Array of the txid(s) which the proof commits to, or empty array if the proof is invalid
*/
verifyTxOutProof({
proof,
}: VerifyTxOutProof): Promise<VerifyTxOutProofResponse> {
return this._client.request('verifytxoutproof', [proof]);
}
}
Source