def test_get_hub_liquidity(server_db):
# confirmed fund
hub_wif = lib.load_wif()
hub_address = keys.address_from_wif(hub_wif)
unsigned_rawtx = api.create_send(**{
'source': FUNDING_ADDRESS,
'destination': hub_address,
'asset': ASSET,
'quantity': 2000000,
'regular_dust_size': 2000000
})
signed_rawtx = scripts.sign_deposit(get_txs, FUNDING_WIF, unsigned_rawtx)
api.sendrawtransaction(tx_hex=signed_rawtx)
assert lib.get_hub_liquidity() == {
'A7736697071037023001': 0,
'BTC': 2000000,
'XCP': 2000000
}
# unconfirmed send
wif = keys.generate_wif("XTN")
address = keys.address_from_wif(wif)
unsigned_rawtx = api.create_send(**{
'source': hub_address,
'destination': address,
'asset': ASSET,
'quantity': 1000000,
'fee': 1000000
})
signed_rawtx = scripts.sign_deposit(get_txs, hub_wif, unsigned_rawtx)
util_test.insert_unconfirmed_raw_transaction(signed_rawtx, server_db)
# counts unconfurmed sends
assert lib.get_hub_liquidity() == {
'A7736697071037023001': 0,
'BTC': 0, # no utxos left
'XCP': 1000000
}
# unconfurmed fund
unsigned_rawtx = api.create_send(**{
'source': FUNDING_ADDRESS,
'destination': hub_address,
'asset': ASSET,
'quantity': 2000000,
'regular_dust_size': 2000000
})
signed_rawtx = scripts.sign_deposit(get_txs, FUNDING_WIF, unsigned_rawtx)
util_test.insert_unconfirmed_raw_transaction(signed_rawtx, server_db)
# doesnt counts unconfurmed funds
assert lib.get_hub_liquidity() == {
'A7736697071037023001': 0,
'BTC': 0, # no utxos left
'XCP': 1000000
}
utxos = api.get_unspent_txouts(address=hub_address, unconfirmed=False)
assert utxos == []
def gen_funded_wif(asset, asset_quantity, btc_quantity):
src_wif = DP["addresses"][0][2]
src_address = address_from_wif(src_wif)
dest_wif = generate_wif(netcode=etc.netcode)
dest_address = address_from_wif(dest_wif)
unsigned_rawtx = api.create_send(**{
'source': src_address,
'destination': dest_address,
'asset': asset,
'quantity': asset_quantity,
'regular_dust_size': btc_quantity
})
signed_rawtx = scripts.sign_deposit(get_txs, src_wif, unsigned_rawtx)
api.sendrawtransaction(tx_hex=signed_rawtx)
return dest_wif
def gen_funded_wif(asset, asset_quantity, btc_quantity):
src_wif = DP["addresses"][0][2]
src_address = address_from_wif(src_wif)
dest_wif = generate_wif(netcode=etc.netcode)
dest_address = address_from_wif(dest_wif)
unsigned_rawtx = api.create_send(
**{
'source': src_address,
'destination': dest_address,
'asset': asset,
'quantity': asset_quantity,
'regular_dust_size': btc_quantity
})
signed_rawtx = scripts.sign_deposit(get_tx, src_wif, unsigned_rawtx)
api.sendrawtransaction(tx_hex=signed_rawtx)
return dest_wif
def send_funds(destination, asset, quantity):
from picopayments_hub import api
try:
regular_dust_size = 5500 # TODO get from cplib
fee_per_kb = 25000 # TODO get from cplib
fee = int(fee_per_kb / 2)
extra_btc = (fee + regular_dust_size) * 3
wif = load_wif()
address = keys.address_from_wif(wif)
utxos = _get_hub_utxos(address, asset, quantity, extra_btc)
unsigned_rawtx = api.create_send(
source=address,
destination=destination,
asset=asset,
regular_dust_size=extra_btc,
quantity=quantity,
disable_utxo_locks=True,
custom_inputs=utxos,
)
signed_rawtx = scripts.sign_deposit(get_txs, wif, unsigned_rawtx)
txid = publish(signed_rawtx)
assert txid, "Failed to publish transaction: {0}".format(signed_rawtx)
return {"txid": txid, "rawtx": signed_rawtx}
except err.InsufficientFunds:
print("Insufficient funds!")
return None
def test_block_send():
alice_wif = util.gen_funded_wif("XCP", 1000000, 1000000)
client = Mpc(util.MockAPI(auth_wif=alice_wif))
bob_wif = keys.generate_wif(netcode=etc.netcode)
bob_address = keys.address_from_wif(bob_wif)
txid = client.block_send(source=alice_wif, destination=bob_address,
asset="XCP", quantity=42)
assert txid is not None
def test_block_send():
alice_wif = util.gen_funded_wif("XCP", 1000000, 1000000)
client = Mpc(util.MockAPI(auth_wif=alice_wif))
bob_wif = keys.generate_wif(netcode=etc.netcode)
bob_address = keys.address_from_wif(bob_wif)
txid = client.block_send(source=alice_wif,
destination=bob_address,
asset="XCP",
quantity=42)
assert txid is not None
def block_send(self, **kwargs):
"""TODO doc string"""
# replace source wif with address
wif = kwargs.pop("source")
kwargs["source"] = keys.address_from_wif(wif)
# create, sign and publish transaction
unsigned_rawtx = self.api.create_send(**kwargs)
signed_rawtx = self.sign(unsigned_rawtx, wif)
return self.publish(signed_rawtx)
def status(handle=None, verbose=False):
""" Get status of connections and wallet.
Args:
handle (str, default=None): Optionally limit to given handle.
verbose (bool, default=False): Optionally show additional information.
Returns:
{
"connections": {
"a0b206d1f68edb1aa24084752b5693a9022349dc547fb9952aa510003e93": {
"asset": "XCP",
"balance": 31337,
"status": "open",
"ttl": 404
}
},
"wallet": {
"address": "n2WQGAvnDS1vf7uXToLou6kLxJXRGFHo2b",
"balances": {
"BTC": 926109330,
"XCP": 140982404156
}
}
}
"""
data = _load_data()
hub_api = _hub_api()
result = {
"connections": {},
"wallet": {
"address": keys.address_from_wif(load_wif()),
"balances": balances()
}
}
for _handle, connection_data in data["connections"].items():
if handle is not None and _handle != handle:
continue
client = Mph.deserialize(hub_api, connection_data)
status = client.get_status()
if verbose:
status["data"] = connection_data
result["connections"][_handle] = status
else:
result["connections"][_handle] = {
"asset": status["asset"],
"balance": status["balance"],
"ttl": status["ttl"],
"status": status["status"],
"payments_queued": connection_data["payments_queued"]
}
return result
def gen_funded_wif(asset, asset_quantity, btc_quantity):
src_wif = DP["addresses"][0][2]
src_address = address_from_wif(src_wif)
dest_wif = generate_wif(netcode=etc.netcode)
dest_address = address_from_wif(dest_wif)
rawtx = api.create_send(
**{
'source': src_address,
'destination': dest_address,
'asset': asset,
'quantity': asset_quantity,
'regular_dust_size': btc_quantity
})
api.sendrawtransaction(tx_hex=rawtx)
# entries = api.get_balances(filters=[
# {"field": "address", "op": "==", "value": dest_address},
# {"field": "asset", "op": "==", "value": asset},
# ])
# assert entries[0]["quantity"] == asset_quantity
# assert entries[0]["address"] == dest_address
# assert entries[0]["asset"] == asset
return dest_wif
def _history_add_rawtx(self, rawtx, action, wallet_tx=True):
address = None
if wallet_tx: # FIXME deduce from input/output addresses
address = keys.address_from_wif(self.api.auth_wif)
asset_quantity, btc_quantity = self.get_transferred(rawtx,
asset=self.asset,
address=address)
history_add_entry(
handle=self.handle,
action=action,
id=util.gettxid(rawtx),
fee="{quantity}{asset}".format(quantity=abs(btc_quantity),
asset="BTC"),
quantity='{quantity}{asset}'.format(quantity=abs(asset_quantity),
asset=self.asset))
def balances(asset=None, address=None):
""" Get balances for address or current wallet.
Args:
asset (str, default=None): Optionally filter for given asset.
address (str, default=None): Optionally provide address to check,
uses wallet by default
Returns:
Dict mapping asset to available quantity in satoshis,
Unconfirmed assets are ignored.
{
"BTC": 926109330,
"XCP": 140982404156
}
"""
hub_api = _hub_api()
assets = [asset] if asset else None
if address is None:
address = keys.address_from_wif(_load_wif())
return Mpc(hub_api).get_balances(address, assets=assets)
def create_hub_connection(asset, client_pubkey,
h2c_spend_secret_hash, hub_rpc_url):
# current terms and asset
data = {"asset": asset}
current_terms = get_terms().get(asset)
data.update(current_terms)
# new hub key
hub_wif = load_wif()
data["hub_pubkey"] = keys.pubkey_from_wif(hub_wif)
data["hub_address"] = keys.address_from_wif(hub_wif)
# client key
data["client_pubkey"] = client_pubkey
data["client_address"] = keys.address_from_pubkey(client_pubkey,
netcode=etc.netcode)
# spend secret for receive channel
data.update(create_secret())
# send micropayment channel
data["h2c_spend_secret_hash"] = h2c_spend_secret_hash
# connection
handle = util.b2h(os.urandom(32))
data["handle"] = handle
data["hub_rpc_url"] = hub_rpc_url
db.add_hub_connection(data)
return (
{
"handle": handle,
"spend_secret_hash": data["secret_hash"],
"channel_terms": current_terms
},
hub_wif
)
def get_hub_liquidity(assets=None):
assets = _terms_assets(assets=assets)
if "BTC" not in assets:
assets.append("BTC")
address = keys.address_from_wif(load_wif())
return get_balances(address, assets=assets)
# this is require near the top to do setup of the test suite
# from counterpartylib.test import conftest
from counterpartylib.test.util_test import CURR_DIR as CPLIB_TESTDIR
from counterpartylib.test.fixtures.params import DP
from counterpartylib.lib.micropayments.control import get_balance
from counterpartylib.lib.api import dispatcher
from micropayment_core.keys import address_from_wif
from micropayment_core.keys import generate_wif
from picopayments import api
FIXTURE_SQL_FILE = CPLIB_TESTDIR + '/fixtures/scenarios/unittest_fixture.sql'
FIXTURE_DB = tempfile.gettempdir() + '/fixtures.unittest_fixture.db'
ALICE_WIF = DP["addresses"][0][2]
ALICE_ADDRESS = address_from_wif(ALICE_WIF)
BOB_WIF = generate_wif(netcode="XTN")
BOB_ADDRESS = address_from_wif(BOB_WIF)
@pytest.mark.usefixtures("picopayments_server")
def test_commit_tx_alpha():
rawtx = api.create_send(
**{
'source': ALICE_ADDRESS,
'destination': BOB_ADDRESS,
'asset': 'XCP',
'quantity': 33,
'regular_dust_size': 42
})
# from counterpartylib.test import conftest
from counterpartylib.test.util_test import CURR_DIR as CPLIB_TESTDIR
from counterpartylib.test.fixtures.params import DP
from counterpartylib.test import util_test
from micropayment_core import keys
from picopayments_hub import api
from picopayments_hub import lib
from micropayment_core import scripts
FIXTURE_SQL_FILE = CPLIB_TESTDIR + '/fixtures/scenarios/unittest_fixture.sql'
FIXTURE_DB = tempfile.gettempdir() + '/fixtures.unittest_fixture.db'
ASSET = "XCP"
FUNDING_WIF = DP["addresses"][0][2] # XTC: 91950000000, BTC: 199909140
FUNDING_ADDRESS = keys.address_from_wif(FUNDING_WIF)
def get_txs(txids):
return api.getrawtransaction_batch(txhash_list=txids)
@pytest.mark.usefixtures("picopayments_server")
def test_get_hub_liquidity(server_db):
# confirmed fund
hub_wif = lib.load_wif()
hub_address = keys.address_from_wif(hub_wif)
unsigned_rawtx = api.create_send(**{
'source': FUNDING_ADDRESS,
'destination': hub_address,
from picopayments_hub import api
from picopayments_hub import lib
from picopayments_hub import cron
from tests import util
# from tests.util import MockAPI
FIXTURE_SQL_FILE = CPLIB_TESTDIR + '/fixtures/scenarios/unittest_fixture.sql'
FIXTURE_DB = tempfile.gettempdir() + '/fixtures.unittest_fixture.db'
ASSET = "XCP"
FUNDING_WIF = DP["addresses"][0][2] # XTC: 91950000000, BTC: 199909140
FUNDING_ADDRESS = address_from_wif(FUNDING_WIF)
def get_txs(txids):
return api.getrawtransaction_batch(txhash_list=txids)
@pytest.mark.usefixtures("picopayments_server")
def test_simulation_xcp():
# fund server
for i in range(2):
address = lib.get_funding_address()
unsigned_rawtx = api.create_send(**{
'source': FUNDING_ADDRESS,
'destination': address,
# this is require near the top to do setup of the test suite
# from counterpartylib.test import conftest
from counterpartylib.test.util_test import CURR_DIR as CPLIB_TESTDIR
from picopayments_hub import lib
from picopayments_hub import api
from pycoin.key.validate import is_address_valid
from micropayment_core.keys import address_from_wif
from counterpartylib.test.fixtures.params import DP
# from micropayment_core import scripts
FIXTURE_SQL_FILE = CPLIB_TESTDIR + '/fixtures/scenarios/unittest_fixture.sql'
FIXTURE_DB = tempfile.gettempdir() + '/fixtures.unittest_fixture.db'
FUNDING_WIF = DP["addresses"][0][2] # XTC: 91950000000, BTC: 199909140
FUNDING_ADDRESS = address_from_wif(FUNDING_WIF)
def get_txs(txids):
return api.getrawtransaction_batch(txhash_list=txids)
@pytest.mark.usefixtures("picopayments_server")
def test_get_funding_addresses():
address = lib.get_funding_address()
assert (is_address_valid(address, allowable_netcodes=["XTN"]))
@pytest.mark.usefixtures("picopayments_server")
def test_validate_read_unknown_asset():
terms = lib.get_terms(["deadbeef"])
def get_funding_address():
return keys.address_from_wif(load_wif())
