示例#1
0
def sendtoaddress(address='',
                  amount=0.0,
                  comment='',
                  comment_to='',
                  subtractFeeFromAmt=False):
    '''
    The sendtoaddress method sends an amount to a given address.
    The amount is real and is rounded to the nearest 0.00000001
    :param address: (string, required)	the receiving address
    :param amount: (numeric, required) the amount to send (json requires
        all decimals values less than 1 begin with the characters '0.')
    :param comment: (string, optional)	a comment used to store what the
        transaction is for; this is not part of the transaction,
        just kept in your wallet
    :param comment_to: (string, optional) a comment to store the name
        of the person or organization to which you're sending the
        transaction; this is stored in your local wallet file only
    :param subtractFeeFromAmt: (boolean, optional, default=false)
        when true, the fee will be deducted from the amount being sent
    :return: "transaction_id" (JSON string) the transaction id
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "sendtoaddress", ' \
                '"params": ["' + str(address) + '", ' + str(amount) +\
                    ', "' + str(comment) + '", "' + str(comment_to) +\
                    '", ' + str(subtractFeeFromAmt).lower() + '] }'
    return rpc.rpc_request(data)
def getsnapshot(top=0):
    '''
    The getsnapshot method returns a snapshot of addresses and their
    amounts at the asset chain's current height.
    The method requires addressindex to be enabled.
    :param top: (number, optional)	Only return this many addresses,
        i.e. top N rich lis
    :return: JSON string containing:
        "addresses"	(array of jsons) the array containing the address
            and amount details
        "addr" (string) an address
        "amount" (number) the amount of coins in the above address
        "total"	(numeric) the total amount in snapshot
        "average" (numeric)	the average amount in each address
        "utxos"	(number) the total number of UTXOs in snapshot
        "total_addresses" (number) the total number of addresses
            in snapshot.
        "start_height" (number) the block height snapshot began
        "ending_height"	(number) the block height snapshot finished,
        "start_time" (number) the unix epoch time snapshot started
        "end_time" (number) the unix epoch time snapshot finished
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getsnapshot", ' \
                '"params": ["' + str(top) + '"] }'
    return rpc.rpc_request(data)
示例#3
0
def listreceivedbyaddress(minconf=1,
                          includeEmpty=False,
                          includeWatchOnly=False):
    '''
    The listreceivedbyaddress method lists balances by receiving address
    :param minconf:(numeric, optional, default=1) the minimum number of
        confirmations before payments are included
    :param includeEmpty:(numeric, optional, default=false) whether to
        include addresses that haven't received any payments
    :param includeWatchOnly:(bool, optional, default=false)	whether to
        include watchonly addresses (see 'importaddress')
    :return:JSON string:
        "involvesWatchonly"	(bool) only returned if imported addresses were
            involved in transaction
        "address" (string) the receiving address
        "account" (string) DEPRECATED the account of the receiving address;
            the default account is ""
        "amount" (numeric) the total amount received by the address
        "confirmations"	(numeric) a confirmation number that is dPoW aware;
        "rawconfirmations" (numeric) the raw confirmations of the most
            recent transaction included (number of blocks on top of this
            transaction's block)
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "listreceivedbyaddress", ' \
                '"params": [' + str(minconf) + ', ' +\
                    str(includeEmpty).lower() + ', ' +\
                    str(includeWatchOnly).lower() + '] }'
    return rpc.rpc_request(data)
示例#4
0
def z_shieldcoinbase(fromaddress='', toaddress='', fee=0.0001, limit=50):
    '''
    The z_shieldcoinbase method shields transparent coinbase funds by
    sending the funds to a shielded z address.
    :param fromaddress: (string, required)	the address is a t address
        or "*" for all t address belonging to the wallet
    :param toaddress: (string, required)	the address is a z address
    :param fee: (numeric, optional, default=0.0001)	the fee amount to
        attach to this transaction
    :param limit: (numeric, optional, default=50) limit on the maximum
        number of utxos to shield; set to 0 to use node option
        mempooltxinputlimit
    :return: JSON string:
        "remainingUTXOs" (numeric) the number of coinbase utxos still
            available for shielding
        "remainingValue" (numeric) the value of coinbase utxos still
            available for shielding
        "shieldingUTXOs" (numeric) the number of coinbase utxos
            being shielded
        "shieldingValue" (numeric) the value of coinbase utxos
            being shielded
        "opid" (string) an operationid to pass to z_getoperationstatus
            to get the result of the operation
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "z_shieldcoinbase", ' \
                '"params": ["'+str(fromaddress)+'", "'+\
                    str(toaddress)+(', '+str(fee) if fee != 0.0001 else '')+\
                    (', '+str(limit) if limit != 50 else '')+\
           '"] }'
    return rpc.rpc_request(data)
示例#5
0
def z_listunspent(minconf=1,
                  maxconf=9999999,
                  includeWatchOnly=False,
                  addresses=['']):
    '''
    The z_listunspent method returns an array of unspent shielded notes
    :param minconf: (numeric, optional, default=1)	the minimum
        confirmations to filter
    :param maxconf: (numeric, optional, default=9999999) the maximum
        confirmations to filter
    :param includeWatchOnly: (bool, optional, default=false) whether
        to also include watchonly addresses
    :param addresses: [string] a list of z addresses (both Sprout and
        Sapling) to act as a filter; duplicate addresses are not allowed
    :return: JSON string
    '''
    addr_list = "["
    for addr in addresses:
        addr_list += "\"" + str(addr) + "\","
    if (len(addresses) > 0):
        addr_list = addr_list[:-1]
    addr_list += "]"
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "z_listunspent", ' \
                '"params": ['+str(minconf)+', '+str(maxconf)+\
                    ', '+str(includeWatchOnly).lower()+', '+addr_list+'] }'
    return rpc.rpc_request(data)
示例#6
0
def z_listreceivedbyaddress(address='', minconf=1):
    '''
    The z_listreceivedbyaddress method returns a list of amounts
    received by a z address belonging to the node’s wallet.
    :param address: (string)	the private address.
    :param minconf: (numeric, optional, default=1)	only include
        transactions confirmed at least this many times
    :return: JSON string:
        txid (string) the transaction id
        amount (numeric) the amount of value in the note
        memo (string ) hexadecimal string representation of memo field
        "confirmations"	(numeric) a confirmation number that is
            dPoW aware;
        "rawconfirmations" (numeric) the raw confirmations
            (number of blocks on top of this transaction's block)
        jsindex	(sprout) (numeric, received only by sprout addresses)
            the joinsplit index
        jsoutindex (numeric, received only by sprout addresses)
            the output index of the joinsplit
        outindex (numeric, sapling)	the output index
        change (boolean) true if the address that received the note is also
            one of the sending addresses
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "z_listreceivedbyaddress", ' \
                '"params": ["'+str(address)+'", '+str(minconf)+'] }'
    return rpc.rpc_request(data)
示例#7
0
def z_getoperationresult(operationid=['']):
    '''
    The z_getoperationresult method retrieves the result and status
    of an operation which has finished, and then removes the operation
    from memory
    :param operationid: [string, optional]	a list of operation ids to
        query; if not provided, the method examines all operations
        known to the node
    :return: JSON String
        "id" (string) the operation id
        "status" (string) the result of the operation; can be success
        "creation_time" (numeric) the creation time, in seconds since
            epoch (Jan 1 1970 GMT)
        "result": { ... } (array of json objects)
        "txid":	(string) the transaction id
        "execution_secs" (numeric) the length of time to calculate the
            transaction
        "method" (string) the name of the method used in the operation
        "params": { ... } (json)
        "fromaddress" (string) the address from which funds are drawn
        "amounts": [ ... ]	(array of json objects)
        "address" (string) the receiving address
        "amount" (numeric) the amount to receive
        "minconf" (numeric)	the minimum number of confirmations required
        "fee" (numeric) the transaction fee
    '''
    oppid_list = "["
    for oppid in operationid:
        oppid_list += "\"" + str(oppid) + "\","
    if (len(operationid) > 0):
        oppid_list = oppid_list[:-1]
    oppid_list += "]"
    data = '{' + rpc.get_request_metadata(
    ) + ', "method": "z_getoperationresult", "params": [' + oppid_list + '] }'
    return rpc.rpc_request(data)
示例#8
0
def getblocktemplate(mode='', capabilities=[''], support=''):
    '''
    The getblocktemplate method returns data that is necessary
    to construct a block.
    :param mode: (string, optional)	this must be set to
        "template" or omitted
    :param capabilities: [string, optional] a list of capability strings
    :param support: (string) client side supported features: "longpoll",
        "coinbasetxn", "coinbasevalue", "proposal", "serverlist", "workid"
    :return: JSON string with details necessary to construct a block.
    '''
    cap_list = '['
    for cap in capabilities:
        cap_list += '"' + cap + '",'
    if (len(capabilities) > 0):
        cap_list = cap_list[:-1]
    cap_list += ']'
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getblocktemplate", ' \
                '"params": [{' +\
                    ('"mode":"'+str(mode)+'",' if mode != '' else '')+\
                    ('"capabilities:"'+cap_list if (len(capabilities) > 0 and
                        capabilities[0] != '') else '') +\
                    ('"support":"'+support+'"' if support != '' else '') +\
           '}] }'
    return rpc.rpc_request(data)
示例#9
0
def getwalletinfo():
    '''
    The getwalletinfo method returns an object containing various
    information about the wallet state.
    :return: JSON string:
            "walletversion" (numeric) the wallet version
            "balance" (numeric) the total confirmed balance of the wallet
            "unconfirmed_balance" (numeric) the total unconfirmed
                balance of the wallet
            "immature_balance" (numeric) the total immature balance
                of the wallet
            "txcount" (numeric) the total number of transactions
                in the wallet
            "keypoololdest" (numeric) the timestamp (seconds since GMT
                epoch) of the oldest pre-generated key in the key pool
            "keypoolsize" (numeric) how many new keys are pre-generated
            "unlocked_until" (numeric) the timestamp in seconds since
                epoch (midnight Jan 1 1970 GMT) that the wallet is
                unlocked for transfers, or 0 if the wallet is locked
            "paytxfee" (numeric) the transaction fee configuration,
                given as the relevant COIN per KB
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getwalletinfo", ' \
                '"params": [] }'
    return rpc.rpc_request(data)
def getaddressdeltas(addresses=[""], start=0, end=0, chainInfo=False):
    '''
    The getaddressdeltas method returns all confirmed balance
    changes of an address.
    :param addresses: [string] a list of addresses
    :param start: (number) the start block height
    :param end: (number) the end block height
    :param chainInfo:(boolean) include chain info in results
        (only applies if start and end specified)
    :return: JSON string containing:
        "satoshis" (number) the difference in satoshis
        "txid" (string) the related transaction id
        "index"	(number) the related input or output index
        "height" (number) the block height
        "address" (string) the address
    '''
    addr_list = "["
    for addr in addresses:
        addr_list += "\"" + str(addr) + "\","
    if (len(addresses) > 0):
        addr_list = addr_list[:-1]
    addr_list += "]"
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getaddressdeltas", ' \
                '"params": [{"addresses": ' + str(addr_list) +\
                    ',"start":' + str(start) + ',"end":' + str(end) +\
                    ',"chainInfo":' + str(chainInfo).lower() + '}]}'
    return rpc.rpc_request(data)
def notaries(height=0, timestamp=0):
    '''
    The notaries method returns the public key, BTC address,
    and KMD address for each Komodo notary node.
    Either or both of the height and timestamp parameters will suffice.
    :param height: (number)	the block height desired for the query
    :param timestamp: (number) the timestamp of the block
        desired for the query
    :return: JSON string containing:
        "notaries": [ ... ]	(array)
        "pubkey" (string) the public signing key of the indicated
            notary node, used on the KMD network to create notary-node
            authorized transactions
        "BTCaddress" (string) the public BTC address the notary node uses
            on the BTC blockchain to create notarizations
        "KMDaddress" (string) the public KMD address the notary node uses
            on the KMD blockchain to create notarizations
        "numnotaries" (number) the number of notary nodes; typically this
            value is 64, but the value may vary on rare circumstances,
            such as during election seasons
        "height" (number) the block height number at which the notary-node
            information applies
        "timestamp" (number) the timestamp at which the notary-node
            information applies
    '''
    options = ('"' + str(height) + '", "' + str(timestamp) + '"' if
               (height != 0 and timestamp != 0) else
               ('"' + str(height) + '"' if height > 0 else
                (('"' + str(timestamp) + '"' if timestamp > 0 else ''))))
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "notaries", ' \
                '"params": ['+options+'] ' \
            '}'
    return rpc.rpc_request(data)
def getblock(block_id=1, verbose=True):
    '''
    The getblock method returns the block's relevant state information
    :param block_id: (string OR number) block_id can be
        block-hash (string) OR block-height (number)
    :param verbose: (boolean, optional, default=true) true returns
        a json object, false returns hex-encoded data
    :return: JSON string containing:
        "hash" (string)	the block hash (same as provided hash)
        "confirmations" (numeric) a confirmation num that is dPoW aware
        "rawconfirmations" (numeric) the raw confirmations
            (number of blocks on top of this block); the returned value
             is -1 if the block is not on the main chain
        "size" (numeric) the block size
        "height" (numeric) the block height or index (same as provided
            height)
        "version" (numeric) the block version
        "merkleroot" (string) the merkle root
        "tx"  ["tx_id",...]	array of strings
        "time" (numeric) the block time in seconds since epoch
        "nonce" (numeric) the nonce
        "bits" (string) the bits
        "difficulty" (numeric) the difficulty
        "previousblockhash" (string) the hash of the previous block
        "nextblockhash" (string) the hash of the next block
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getblock", ' \
                '"params": ["'+str(block_id)+'", '+str(verbose).lower()+']' \
            ' }'
    return rpc.rpc_request(data)
def getaddressmempool(addresses=[""]):
    '''
    The getaddressmempool method returns all mempool deltas for an
    address, or addresses. It requires addressindex to be enabled.
    :param addresses: [string] a list of addresses
    :return: JSON string containing:
        "address" (string) the address
        "txid" (string)	the related txid
        "index"	(number) the related input or output index
        "satoshis"	(number) the difference in satoshis
        "timestamp"	(number) the time the transaction entered the
            mempool (seconds)
        "prevtxid" (string) the previous txid (if spending)
        "prevout" (string) the previous transaction output index
            (if spending)
    '''
    addr_list = "["
    for addr in addresses:
        addr_list += "\"" + str(addr) + "\","
    if (len(addresses) > 0):
        addr_list = addr_list[:-1]
    addr_list += "]"
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getaddressmempool", ' \
                '"params": [{"addresses": ' + str(addr_list) + '}] }'
    return rpc.rpc_request(data)
def getchaintxstats(nblocks=1, blockhash=''):
    '''
    The method getchaintxstats returns statistics about the total
    number and rate of transactions in the chain.
    :param nblocks: (numeric, optional)	the number of blocks in the
        averaging window.
    :param blockhash: (string, optional) the hash of the block which
        ends the window
    :return: JSON string containing:
        "time" (numeric) the timestamp for the final block in the window
        "txcount" (numeric) the total number of transactions in the
            chain up to this point
        "window_final_block_hash" (string) the hash of the final block
            in the window
        "window_block_count" (numeric) the size of the window in the
            number of blocks
        "window_tx_count" (numeric)	the number of transactions in the
            window; this value is only returned if window_block_count is > 0.
        "window_interval" (numeric)	the elapsed time in the window in
            seconds; this value is only returned if window_block_count is > 0.
        "txrate" (numeric)	the average rate of transactions per second in
            the window; this value is only returned if window_interval is > 0
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getchaintxstats", ' \
                '"params": ['+str(nblocks)+', "'+str(blockhash)+'"] ' \
            '}'
    return rpc.rpc_request(data)
def createrawtransaction(transactions={'': 0}, amounts={'', 0.0}):
    '''
    The createrawtransaction method creates a transaction, spending
    the given inputs and sending to the given addresses.
    :param transactions: {string, number} a dictinary of txid (string)
        as key and vout (number) as value.
    :param amounts: {string, number} a dictinary of address (string)
        as key and amount (number) as value.
    :return: "transaction" (JSON string) a hex string of the transaction
    '''
    tx_list = '['
    for tx_id in transactions:
        tx_list += '{"txid":"' + tx_id + '", "vout": ' +\
                   str(transactions[tx_id]) + '},'
    if (len(transactions) > 0):
        tx_list = tx_list[:-1]
    tx_list += ']'
    amount_list = '{'
    for addr in amounts:
        amount_list += '"' + addr + '":' + str(amounts[addr]) + ','
    if (len(amounts) > 0):
        amount_list = amount_list[:-1]
    amount_list += '}'
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "createrawtransaction", ' \
                '"params": ['+tx_list+', '+amount_list+'] }'
    return rpc.rpc_request(data)
def getaddressutxos(addresses=[""], chainInfo=False):
    '''
    The getaddressutxos method returns all unspent outputs for
    an address. It requires addressindex to be enabled.
    :param addresses: [string] a list of addreses
    :param chainInfo: (boolean)	include chain info with results
    :return: JSON string containing:
        "address" (string) the address
        "txid" (string) the output txid
        "height" (number) the block height
        "outputIndex" (number) the output index
        "script" (string) the script hex encoded
        "satoshis" (number) the number of satoshis of the output
    '''
    addr_list = "["
    for addr in addresses:
        addr_list += "\"" + str(addr) + "\","
    if (len(addresses) > 0):
        addr_list = addr_list[:-1]
    addr_list += "]"
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getaddressutxos", ' \
                '"params": [{"addresses": ' + str(addr_list) +\
                    ', "chainInfo": ' + str(chainInfo).lower() + '}] }'
    return rpc.rpc_request(data)
def kvupdate(key='', value='', days=1, passphrase=''):
    '''
    The kvupdate method stores a key/value pair via OP_RETURN.
    :param key: (string, required) key (should be unique)
    :param value: (string, required) value
    :param days: (numeric, required) amount of days before the
        key expires (1440 blocks/day); minimum 1 day
    :param passphrase: (string, optional) passphrase required
        to update this key
    :return: JSON string containing:
        "coin" (string)	the chain on which the key is stored
        "height" (numeric) the height at which the key was stored
        "expiration" (numeric) the height at which the key will expire
        "flags" (string the amount of days the key will be stored
        "key" (numeric) the stored key
        "keylen" (numeric) the length of the key
        "value" (numeric) the stored value
        "valuesize" (string) the length of the stored value
        "fee" (string) the transaction fee paid to store the key
        "txid" (string) the transaction id
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "kvupdate", ' \
                '"params": ["'+str(key)+'","'+str(value)+'","'+str(days)+\
                '", "'+str(passphrase)+'"] ' \
            '}'
    return rpc.rpc_request(data)
def getrawmempool(verbose=False):
    '''
    The getrawmempool method returns all transaction ids in the
    memory pool as a json array of transaction ids.
    :param verbose: (boolean, optional, default=false) true for a json
        object, false for a json array of transaction ids
    :return: JSON string, if verbose=False: "transaction_id" (string)
        the transaction id, if verbose=True:
        "transaction_id": { .... } (json object)
        "size" (numeric) the transaction size in bytes
        "fee" (numeric) the transaction fee
        "time" (numeric) the local time transaction entered pool in
            seconds since 1 Jan 1970 GMT
        "height" (numeric) the block height wherein the transaction entered
            the mempool
        "startingpriority" (numeric) the priority when the transaction
            entered the mempool
        "currentpriority" (numeric)	the transaction priority at the current
            height
        "depends": { ... } (array) unconfirmed transactions used as
            inputs for this transaction
        "transaction_id" (string) the parent transaction id
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getrawmempool", ' \
                '"params": ['+str(verbose).lower()+'] ' \
            '}'
    return rpc.rpc_request(data)
def clearbanned():
    '''
    The clearbanned method clears all banned IPs
    :return: JSON string
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "clearbanned", "params": [] }'
    return rpc.rpc_request(data)
def getinfo():
    '''
    The getinfo method returns an object containing various state info
    :return: JSON string conataining wallet state and network state info
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getinfo", ' \
                '"params": [] }'
    return rpc.rpc_request(data)
def stop():
    '''
    The stop method instructs the coin daemon to shut down.
    :return: JSON string: Komodo server stopping
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "stop", ' \
                '"params": [] }'
    return rpc.rpc_request(data)
def getconnectioncount():
    '''
    The getconnectioncount method returns the number of connections
    to other nodes.
    :return: n (numeric) the connection count
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getconnectioncount", "params": [] }'
    return rpc.rpc_request(data)
def getnetworkinfo():
    '''
    The getnetworkinfo method returns an object containing various state
    info regarding p2p networking.
    :return: JSON string with various state info regarding p2p networking.
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getnetworkinfo", "params": [] }'
    return rpc.rpc_request(data)
示例#24
0
def getlocalsolps():
    '''
    The getlocalsolps method returns the average local solutions
    per second since this node was started.
    :return: "data" (numeric) the solutions-per-second average
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
            '"method": "getlocalsolps", ' \
            '"params": [] }'
    return rpc.rpc_request(data)
def disconnectnode(node=''):
    '''
    The disconnectnode method instructs the daemon to immediately
    disconnect from the specified node.
    :param node: (string, required) node_ip:port
    :return: JSON string
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "disconnectnode", "params": ["' + str(node) + '"] }'
    return rpc.rpc_request(data)
示例#26
0
def z_getnewaddress():
    '''
    The z_getnewaddress method returns a new z_address for receiving
    payments
    :return: "z_address" (JSON string) the new z_address
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "z_getnewaddress", ' \
                '"params": [] }'
    return rpc.rpc_request(data)
def ping():
    '''
    The ping method requests that a ping be sent to all other nodes,
    to measure ping time.
    :return: JSON string
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "ping", ' \
                '"params": [] }'
    return rpc.rpc_request(data)
示例#28
0
def getmininginfo():
    '''
    The getmininginfo method returns a json object containing
    mining-related information.
    :return: JSON string with mining-related information.
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "getmininginfo", ' \
                '"params": [] }'
    return rpc.rpc_request(data)
示例#29
0
def jumblr_resume():
    '''
    The jumblr_resume method instructs Jumblr to resume
    the privacy-shielding process.
    :return: JSON string
    '''
    data = '{'+rpc.get_request_metadata()+', ' \
                '"method": "jumblr_resume", ' \
                '"params": [] }'
    return rpc.rpc_request(data)
示例#30
0
def walletlock():
    '''
    The walletlock method re-locks a wallet that has a passphrase
    enabled via encryptwallet.
    :return: JSON string
    '''
    data = '{' + rpc.get_request_metadata() + ', ' \
                '"method": "walletlock", ' \
                '"params": [] }'
    return rpc.rpc_request(data)