def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = operations.Comment_options(
**{
"author": "xeroc",
"permlink": "piston",
"max_accepted_payout": "1000000.000 SBD",
"percent_steem_dollars": 10000,
"allow_votes": True,
"allow_curation_rewards": True,
"extensions": []
})
ops = [operations.Operation(op)]
tx = Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif])
txWire = hexlify(bytes(tx)).decode("ascii")
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
pprint(tx.json())
print("\n")
print(compare[:-130])
print(txWire[:-130])
print("\n")
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareNewWire(self):
# def test_online(self):
# self.maxDiff = None
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
tx = rpc.create_account("xeroc", "fsafaasf", "", False)
pprint(tx)
compare = rpc.serialize_transaction(tx)
ref_block_num = tx["ref_block_num"]
ref_block_prefix = tx["ref_block_prefix"]
expiration = tx["expiration"]
ops = [
transactions.Operation(
transactions.Account_create(**tx["operations"][0][1]))
]
tx = transactions.Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], "BTS")
txWire = hexlify(bytes(tx)).decode("ascii")
print("\n")
print(txWire[:-130])
print(compare[:-130])
def compareConstructedTX(self):
self.maxDiff = None
self.op = operations.Committee_member_create(**{
"fee": {
"amount": 0,
"asset_id": "1.3.0"
},
"committee_member_account": "1.2.0",
"url": "foobar"
})
ops = [Operation(self.op)]
tx = Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
self.cm = rpc.serialize_transaction(tx.json())
print("soll: %s" % self.cm[:-130])
print("ist: %s" % txWire[:-130])
print(txWire[:-130] == self.cm[:-130])
self.assertEqual(self.cm[:-130], txWire[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
wif = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"
ref_block_num = 34294
ref_block_prefix = 3707022213
expiration = "2016-04-06T08:29:27"
op = transactions.Limit_order_cancel(
**{"owner": "",
"orderid": 2141244,
}
)
ops = [transactions.Operation(op)]
tx = transactions.Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif])
txWire = hexlify(bytes(tx)).decode("ascii")
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(transactions.JsonObj(tx))
print("\n")
print(compare[:-130])
print(txWire[:-130])
print("\n")
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareNewWire(self):
# def test_online(self):
# self.maxDiff = None
prefix = "STEEM"
wif = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
tx = rpc.create_account("xeroc", "fsafaasf", "", False)
pprint(tx)
compare = rpc.serialize_transaction(tx)
ref_block_num = tx["ref_block_num"]
ref_block_prefix = tx["ref_block_prefix"]
expiration = tx["expiration"]
ops = [transactions.Operation(transactions.Account_create(**tx["operations"][0][1]))]
tx = transactions.Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
print("\n")
print(txWire[:-130])
print(compare[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = operations.Asset_reserve(
**{
"fee": {
"amount": 0,
"asset_id": "1.3.0"
},
"payer": "1.2.0",
"amount_to_reserve": {
"amount": 1234567890,
"asset_id": "1.3.0"
},
"extensions": []
})
ops = [Operation(op)]
tx = Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], "BTS")
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
print(compare[:-130])
print(txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def main(rpchost, rpcport, expiration, broadcast, proposer):
rpc = GrapheneAPI(rpchost, rpcport)
obj = rpc.get_object("2.0.0")[0]
current_fees = obj["parameters"]["current_fees"]["parameters"]
old_fees = obj["parameters"]["current_fees"]
scale = obj["parameters"]["current_fees"]["scale"] / 1e4
# General change of parameter
changes = {}
# Copy old fees
for f in current_fees:
changes[getOperationNameForId(f[0])] = f[1].copy()
# New fees
changes["account_update"]["fee"] = int(0.02527 / scale * 1e5)
changes["proposal_create"]["fee"] = int(5 / scale * 1e5)
tx = rpc.propose_fee_change(proposer, formatTimeFromNow(expiration),
changes, broadcast)
new_fees = tx["operations"][0][1]["proposed_ops"][0]["op"][1][
"new_parameters"]["current_fees"]
click.echo(json.dumps(DeepDiff(old_fees, new_fees), indent=4))
if not broadcast:
click.echo(
"Set broadcast to 'True' if the transaction shall be broadcast!")
def compareConstructedTX(self):
# FIXME: Bet cancel does not serialize properly
op = operations.Bet_cancel(
**{
"fee": {
"amount": 0,
"asset_id": "1.3.0"
},
"bettor_id": "1.2.5555",
"bet_to_cancel": "1.22.1111",
"prefix": prefix,
})
ops = [Operation(op)]
tx = Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
print(compare[:-130])
print(txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def doit(self, printWire=False):
ops = [Operation(self.op)]
tx = Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops,
)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
if printWire:
print()
print(txWire)
print()
self.assertEqual(self.cm[:-130], txWire[:-130])
if TEST_AGAINST_CLI_WALLET:
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
self.cm = rpc.serialize_transaction(tx.json())
# print("soll: %s" % self.cm[:-130])
# print("ist: %s" % txWire[:-130])
# print(txWire[:-130] == self.cm[:-130])
self.assertEqual(self.cm[:-130], txWire[:-130])
# Test against Bitshares backened
live = peerplays.rpc.get_transaction_hex(tx.json())
# Compare expected result with online result
self.assertEqual(live[:-130], txWire[:-130])
# Compare expected result with online backend
self.assertEqual(live[:-130], self.cm[:-130])
def compareConstructedTX(self):
self.op = operations.Balance_claim(
**{
"fee": {"amount": 0, "asset_id": "1.3.0"},
"deposit_to_account": "1.2.0",
"balance_to_claim": "1.15.0",
"balance_owner_key": prefix + "1111111111111111111111111111111114T1Anm",
"total_claimed": {"amount": 0, "asset_id": "1.3.0"},
"prefix": prefix,
}
)
ops = [Operation(self.op)]
tx = Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops,
)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
self.cm = rpc.serialize_transaction(tx.json())
print("soll: %s" % self.cm)
print("ist: %s" % txWire)
print(txWire[:-130] == self.cm[:-130])
self.assertEqual(self.cm[:-130], txWire[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = transactions.Override_transfer(**{
"fee": {"amount": 0,
"asset_id": "1.3.0"},
"issuer": "1.2.29",
"from": "1.2.104",
"to": "1.2.29",
"amount": {"amount": 100000,
"asset_id": "1.3.105"},
"extensions": []
})
ops = [transactions.Operation(op)]
tx = transactions.Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif], chain=prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(transactions.JsonObj(tx))
print(compare[:-130])
print(txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = transactions.Override_transfer(
**{
"fee": {
"amount": 0,
"asset_id": "1.3.0"
},
"issuer": "1.2.29",
"from": "1.2.104",
"to": "1.2.29",
"amount": {
"amount": 100000,
"asset_id": "1.3.105"
},
"extensions": []
})
ops = [transactions.Operation(op)]
tx = transactions.Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(transactions.JsonObj(tx))
print(compare[:-130])
print(txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareConstructedTX(self):
self.maxDiff = None
self.op = operations.Bid_collateral(**{
'fee': {'amount': 100,
'asset_id': '1.3.0'},
'additional_collateral': {
'amount': 10000,
'asset_id': '1.3.22'},
'debt_covered': {
'amount': 100000000,
'asset_id': '1.3.0'},
'bidder': '1.2.29',
'extensions': []
})
ops = [Operation(self.op)]
tx = Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
self.cm = rpc.serialize_transaction(tx.json())
print("soll: %s" % self.cm[:-130])
print("ist: %s" % txWire[:-130])
print(txWire[:-130] == self.cm[:-130])
self.assertEqual(self.cm[:-130], txWire[:-130])
def run(n=0):
client = GrapheneAPI("localhost", 8092, "", "")
while True:
for i in range(0, random.randint(1, 100)):
print(n, end="", flush=True)
client.transfer("faucet", "init0", "0.00007", "TEST", "", True)
time.sleep(random.randint(0, 3))
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = operations.Comment_options(
**{
"author": "jared",
"permlink": "dpaypy",
"max_accepted_payout": "1000000.000 BBD",
"percent_dpay_dollars": 10000,
"allow_votes": True,
"allow_curation_rewards": True,
"extensions": [
[
0,
{
"beneficiaries": [
{
"weight": 2000,
"account": "good-karma"
},
{
"weight": 5000,
"account": "null"
}
]
}
]
],
}
)
ops = [operations.Operation(op)]
tx = Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif])
txWire = hexlify(bytes(tx)).decode("ascii")
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
pprint(tx.json())
print("\n")
print(compare[:-130])
print(txWire[:-130])
print("\n")
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = operations.Comment_options(
**{
"author": "xeroc",
"permlink": "piston",
"max_accepted_payout": "1000000.000 SBD",
"percent_steem_dollars": 10000,
"allow_votes": True,
"allow_curation_rewards": True,
"extensions": [
[
0,
{
"beneficiaries": [
{
"weight": 2000,
"account": "good-karma"
},
{
"weight": 5000,
"account": "null"
}
]
}
]
],
}
)
ops = [operations.Operation(op)]
tx = Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif])
txWire = hexlify(bytes(tx)).decode("ascii")
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
pprint(tx.json())
print("\n")
print(compare[:-130])
print(txWire[:-130])
print("\n")
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = transactions.Asset_update(**{
"fee": {"amount": 0,
"asset_id": "1.3.0"},
"issuer": "1.2.0",
"asset_to_update": "1.3.0",
"new_options": {
"max_supply": "1000000000000000",
"market_fee_percent": 0,
"max_market_fee": "1000000000000000",
"issuer_permissions": 79,
"flags": 0,
"core_exchange_rate": {
"base": {"amount": 0,
"asset_id": "1.3.0"},
"quote": {"amount": 0,
"asset_id": "1.3.0"}
},
"whitelist_authorities": ["1.2.12", "1.2.13"],
"blacklist_authorities": ["1.2.10", "1.2.11"],
"whitelist_markets": ["1.3.10", "1.3.11"],
"blacklist_markets": ["1.3.12", "1.3.13"],
"description": "Foobar",
"extensions": []
},
"extensions": []
})
ops = [transactions.Operation(op)]
tx = transactions.Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], "BTS")
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
print(compare[:-130])
print(txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def main(rpchost, rpcport, expiration, broadcast, proposer):
rpc = GrapheneAPI(rpchost, rpcport)
""" Update parameters here
"""
updated_parameters = dict(maximum_transaction_size=1048576}
tx = rpc.propose_parameter_change(
proposer, formatTimeFromNow(expiration), updated_parameters, broadcast
)
click.echo(json.dumps(tx, indent=4))
if not broadcast:
click.echo("Set broadcast to 'True' if the transaction shall be broadcast!")
def main(rpchost, rpcport, expiration, broadcast, proposer):
rpc = GrapheneAPI(rpchost, rpcport)
expiration = datetime.utcfromtimestamp(time.time() + int(expiration)).strftime(
"%Y-%m-%dT%H:%M:%S"
)
# Get current fees
obj = rpc.get_object("2.0.0")[0]
old_fees = obj["parameters"]["current_fees"]
scale = int(obj["parameters"]["current_fees"]["scale"]) / 1e4
core_asset = rpc.get_asset("1.3.0")
# Get ticker/current price
market = Market(config.market)
ticker = market.ticker()
# core_exchange_rate = float(ticker["core_exchange_rate"])
settlement_price = float(ticker["quoteSettlement_price"])
# Translate native fee in core_asset fee
new_fees = config.native_fees.copy()
for opName in new_fees:
for f in new_fees[opName]:
if config.force_integer_core_fee:
new_fees[opName][f] = int(
int(config.native_fees[opName][f] / scale * settlement_price)
* 10 ** core_asset["precision"]
)
else:
new_fees[opName][f] = int(
config.native_fees[opName][f]
* 10 ** core_asset["precision"]
/ scale
* settlement_price
)
tx = rpc.propose_fee_change(proposer, expiration, new_fees, broadcast)
new_fees = tx["operations"][0][1]["proposed_ops"][0]["op"][1]["new_parameters"][
"current_fees"
]
# Show differences from previous to new fees
pprint(DeepDiff(old_fees, new_fees))
if not broadcast:
print("=" * 80)
print("Set --broadcast if the transaction shall be broadcast!")
def compareConstructedTX(self):
op = operations.Proposal_update(
**{
'fee_paying_account': "1.2.1",
'proposal': "1.10.90",
'active_approvals_to_add': ["1.2.5"],
"fee": {
"amount": 0,
"asset_id": "1.3.0"
},
})
"""
op = operations.Betting_market_resolve(**{
"fee": {"amount": 0, "asset_id": "1.3.0"},
"betting_market_id": "1.21.1",
"resolution": "win",
"prefix": prefix,
})
op = operations.Bet_cancel_operation(**{
"fee": {"amount": 0, "asset_id": "1.3.0"},
"bettor_id": "1.2.1241",
"bet_to_cancel": "1.22.10",
"prefix": prefix,
})
"""
ops = [Operation(op)]
tx = Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
print(compare[:-130])
print(txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = transactions.Custom_json(
**{
"json": [
"reblog", {
"account":
"xeroc",
"author":
"chainsquad",
"permlink":
"streemian-com-to-open-its-doors-and-offer-a-20-discount"
}
],
"required_auths": [],
"required_posting_auths": ["xeroc"],
"id":
"follow"
})
ops = [transactions.Operation(op)]
tx = transactions.Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif])
txWire = hexlify(bytes(tx)).decode("ascii")
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
pprint(tx.json())
print("\n")
print(compare[:-130])
print(txWire[:-130])
print("\n")
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def run(port, n=0):
client = GrapheneAPI("localhost", port)
client.unlock("password")
transfer = client.get_prototype_operation("transfer_operation")
from_account = client.get_account("faucet")
to_account = client.get_account("xeroc")
transfer[1]["to"] = to_account["id"]
transfer[1]["from"] = from_account["id"]
transfer[1]["amount"]["amount"] = 1 + n
while True:
#builder = client.begin_builder_transaction()
for i in range(0, 200 + random.randint(0, 1000)):
print(n, end="", flush=True)
#client.add_operation_to_builder_transaction(builder, transfer)
client.transfer("faucet", "init0", 100 + n, "TEST", "", True)
def compareConstructedTX(self):
self.op = operations.Bet_place(
**{
"fee": {
"amount": 0,
"asset_id": "1.3.0"
},
"bettor_id": "1.2.1241",
"betting_market_id": "1.21.1",
"amount_to_bet": {
"amount": 1000,
"asset_id": "1.3.1"
},
"backer_multiplier": 2 * GRAPHENE_BETTING_ODDS_PRECISION,
"back_or_lay": "lay",
"prefix": prefix,
})
ops = [Operation(self.op)]
"""
from peerplays import PeerPlays
ppy = PeerPlays()
ops = transactions.addRequiredFees(ppy.rpc, ops)
"""
tx = Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
self.cm = rpc.serialize_transaction(tx.json())
print("soll: %s" % self.cm[:-130])
print("ist: %s" % txWire[:-130])
print(txWire[:-130] == self.cm[:-130])
self.assertEqual(self.cm[:-130], txWire[:-130])
def run():
# testnet = BitShares("wss://node.testnet.bitshares.eu")
testnet = BitShares("ws://this.uptick.rocks:18090")
account = Account("committee-account", full=True, bitshares_instance=testnet)
proposals = account["proposals"]
client = GrapheneAPI("localhost", 8092, "", "")
for proposal in proposals:
pprint(proposal)
if click.confirm("Approve proposal %s" % proposal["id"]):
# Get current fees
core_asset = client.get_asset("1.3.0")
committee_account = client.get_account("committee-account")
proposal = client.get_object(proposal["id"])[0]
prop_op = proposal["proposed_transaction"]["operations"]
tx = client.approve_proposal(
"faucet",
proposal["id"],
{"active_approvals_to_add": [
"committee-member-1",
"committee-member-2",
"committee-member-3",
"committee-member-4",
"committee-member-5",
"committee-member-6",
"committee-member-7",
"committee-member-8",
"committee-member-9",
"committee-member-10"]
},
True)
pprint(tx)
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = operations.Worker_create(
**{
"fee": {
"amount": 0,
"asset_id": "1.3.0"
},
"owner": "1.2.0",
"work_begin_date": "1970-01-01T00:00:00",
"work_end_date": "1970-01-01T00:00:00",
"daily_pay": 0,
"name": "Myname",
"url": "myURL",
"initializer": [1, {
"pay_vesting_period_days": 125
}]
})
ops = [Operation(op)]
tx = Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], "BTS")
txWire = hexlify(bytes(tx)).decode("ascii")
print("=" * 80)
pprint(tx.json())
print("=" * 80)
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
print("soll: %s" % compare[:-130])
print("ist: %s" % txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def doit(self, printWire=False):
ops = [Operation(self.op)]
tx = Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
if printWire:
print()
print(txWire)
print()
self.assertEqual(self.cm[:-130], txWire[:-130])
if TEST_AGAINST_CLI_WALLET:
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
self.cm = rpc.serialize_transaction(tx.json())
# print("soll: %s" % self.cm[:-130])
# print("ist: %s" % txWire[:-130])
# print(txWire[:-130] == self.cm[:-130])
self.assertEqual(self.cm[:-130], txWire[:-130])
def compareNewWire(self):
# def test_online(self):
# self.maxDiff = None
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
tx = rpc.create_account("xeroc", "fsafaasf", "", False)
pprint(tx)
compare = rpc.serialize_transaction(tx)
ref_block_num = tx["ref_block_num"]
ref_block_prefix = tx["ref_block_prefix"]
expiration = tx["expiration"]
ops = [transactions.Operation(transactions.Account_create(**tx["operations"][0][1]))]
tx = transactions.Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], "BTS")
txWire = hexlify(bytes(tx)).decode("ascii")
print("\n")
print(txWire[:-130])
print(compare[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = transactions.Witness_update(
**{"owner": "xeroc",
"url": "foooobar",
"block_signing_key": "STM6zLNtyFVToBsBZDsgMhgjpwysYVbsQD6YhP3kRkQhANUB4w7Qp",
"props": {"account_creation_fee": "10.000 STEEM",
"maximum_block_size": 1111111,
"sbd_interest_rate": 1000},
"fee": "10.000 STEEM",
}
)
ops = [transactions.Operation(op)]
tx = transactions.Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif])
txWire = hexlify(bytes(tx)).decode("ascii")
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(tx.json())
pprint(tx.json())
print("\n")
print(compare[:-130])
print(txWire[:-130])
print("\n")
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = transactions.Account_create(**{
"fee": {"amount": 1467634,
"asset_id": "1.3.0"
},
"registrar": "1.2.33",
"referrer": "1.2.27",
"referrer_percent": 3,
"name": "foobar-f124",
"owner": {"weight_threshold": 1,
"account_auths": [],
"key_auths": [["BTS5TPTziKkLexhVKsQKtSpo4bAv5RnB8oXcG4sMHEwCcTf3r7dqE", 1]],
"address_auths": []
},
"active": {"weight_threshold": 1,
"account_auths": [],
"key_auths": [["BTS5TPTziKkLexhVKsQKtSpo4bAv5RnB8oXcG4sMHEwCcTf3r7dqE", 1]],
"address_auths": []
},
"options": {
"memo_key": "BTS5TPTziKkLexhVKsQKtSpo4bAv5RnB8oXcG4sMHEwCcTf3r7dqE",
"voting_account": "1.2.5",
"num_witness": 26,
"num_committee": 8,
"votes": [
"1:22",
"1:23",
"1:24",
"1:25",
"1:26",
"1:27",
"1:28",
"1:30",
"1:31",
"1:32",
"1:34",
"1:35",
"1:36",
"1:37",
"1:38",
"1:40",
"1:41",
"1:44",
"1:45",
"1:49",
"1:51",
"1:56",
"1:60",
"0:76",
"0:84",
"0:87",
"0:88",
"0:91",
"0:141",
"1:143",
"0:147",
"2:148",
"2:150",
"1:165",
"1:166",
"2:171",
"0:173",
"2:179"
],
"extensions": []
},
"extensions": {}
})
ops = [transactions.Operation(op)]
tx = transactions.Signed_Transaction(
ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops
)
tx = tx.sign([wif], chain=prefix)
txWire = hexlify(bytes(tx)).decode("ascii")
pprint(transactions.JsonObj(tx))
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(transactions.JsonObj(tx))
print(compare[:-130])
print(txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def compareConstructedTX(self):
# def test_online(self):
# self.maxDiff = None
op = transactions.Account_create(
**{
"fee": {
"amount": 1467634,
"asset_id": "1.3.0"
},
"registrar": "1.2.33",
"referrer": "1.2.27",
"referrer_percent": 3,
"name": "foobar-f124",
"owner": {
"weight_threshold":
1,
"account_auths": [],
"key_auths": [[
"BTS5TPTziKkLexhVKsQKtSpo4bAv5RnB8oXcG4sMHEwCcTf3r7dqE",
1
]],
"address_auths": []
},
"active": {
"weight_threshold":
1,
"account_auths": [],
"key_auths": [[
"BTS5TPTziKkLexhVKsQKtSpo4bAv5RnB8oXcG4sMHEwCcTf3r7dqE",
1
]],
"address_auths": []
},
"options": {
"memo_key":
"BTS5TPTziKkLexhVKsQKtSpo4bAv5RnB8oXcG4sMHEwCcTf3r7dqE",
"voting_account":
"1.2.5",
"num_witness":
26,
"num_committee":
8,
"votes": [
"1:22", "1:23", "1:24", "1:25", "1:26", "1:27", "1:28",
"1:30", "1:31", "1:32", "1:34", "1:35", "1:36", "1:37",
"1:38", "1:40", "1:41", "1:44", "1:45", "1:49", "1:51",
"1:56", "1:60", "0:76", "0:84", "0:87", "0:88", "0:91",
"0:141", "1:143", "0:147", "2:148", "2:150", "1:165",
"1:166", "2:171", "0:173", "2:179"
],
"extensions": []
},
"extensions": {}
})
ops = [transactions.Operation(op)]
tx = transactions.Signed_Transaction(ref_block_num=ref_block_num,
ref_block_prefix=ref_block_prefix,
expiration=expiration,
operations=ops)
tx = tx.sign([wif], chain=prefix)
tx.verify([PrivateKey(wif).pubkey], "BTS")
txWire = hexlify(bytes(tx)).decode("ascii")
pprint(transactions.JsonObj(tx))
from grapheneapi.grapheneapi import GrapheneAPI
rpc = GrapheneAPI("localhost", 8092)
compare = rpc.serialize_transaction(transactions.JsonObj(tx))
print(compare[:-130])
print(txWire[:-130])
print(txWire[:-130] == compare[:-130])
self.assertEqual(compare[:-130], txWire[:-130])
def update_price_feed() :
global derived_prices, config
state = {}
for asset in _all_assets + [core_symbol]:
price_median_blockchain[asset] = 0.0
lastUpdate[asset] = datetime.utcnow()
myCurrentFeed[asset] = {}
if configFile.blame != "latest" :
blameFile = config.configPath + "/blame/" + configFile.blame + ".json"
if os.path.isfile(blameFile) :
# Load data from disk for (faster) debugging and verification
with open(blameFile, 'r') as fp:
state = json.load(fp)
# Load feed sources
feed = state["feed"]
# Load configuration from old state
configStruct = state["config"]
for key in configStruct :
# Skip asset config
if key == "asset_config" :
continue
config.__dict__[key] = configStruct[key]
else :
sys.exit("Configuration error: Either set 'blame' to an existing " +
"block number from the blame/ to verify or set it to " +
"'latest' to run the script online! ")
else :
# Load configuration from file
config = configFile
# Get prices online from sources
pool = futures.ThreadPoolExecutor(max_workers=8)
feed = {}
mythreads = {}
for name in config.feedSources :
print("(%s)" % name, end="", flush=True)
mythreads[name] = pool.submit(config.feedSources[name].fetch)
for name in config.feedSources :
print(".", end="", flush=True)
feed[name] = mythreads[name].result()
# rpc variables about bts rpc ##############################################
rpc = GrapheneAPI(config.host, config.port, config.user, config.passwd)
fetch_from_wallet(rpc)
# Determine bts price ######################################################
derived_prices = derive_prices(feed)
# Only publish given feeds #################################################
price_feeds = {}
update_required = False
for asset in asset_list_publish :
# Get Final Price according to price metric
this_asset_config = config.asset_config[asset] if asset in config.asset_config else config.asset_config["default"]
price_metric = this_asset_config["metric"] if "metric" in this_asset_config else config.asset_config["default"]["metric"]
if (asset not in derived_prices or
core_symbol not in derived_prices[asset] or
price_metric not in derived_prices[asset][core_symbol]) :
print("Warning: Asset %s has no derived price!" % asset)
continue
if float(derived_prices[asset][core_symbol][price_metric]) > 0.0:
quote_precision_core = assets[asset]["precision"]
symbol = assets[asset]["symbol"]
assert symbol is not asset
base_precision_cer = assets[blockchain_feed_quote[asset]]["precision"] # core asset
core_price_cer = derived_prices[asset][core_symbol][price_metric] * 10 ** (quote_precision_core - base_precision_cer)
core_price_cer = fractions.Fraction.from_float(core_price_cer).limit_denominator(100000)
denominator_cer = core_price_cer.denominator
numerator_cer = core_price_cer.numerator
quote_precision_settle = assets[asset]["precision"]
symbol = assets[asset]["symbol"]
assert symbol is not asset
base_precision_settle = assets[blockchain_feed_quote[asset]]["precision"] # core asset
core_price_settle = derived_prices[asset]["short_backing_asset"][price_metric] * 10 ** (quote_precision_settle - base_precision_settle)
core_price_settle = fractions.Fraction.from_float(core_price_settle).limit_denominator(100000)
denominator_settle = core_price_settle.denominator
numerator_settle = core_price_settle.numerator
price_feed = {"settlement_price": {
"quote": {"asset_id": assets[blockchain_feed_quote[asset]]["id"],
"amount": denominator_settle
},
"base": {"asset_id": assets[asset]["id"],
"amount": numerator_settle
}
},
"maintenance_collateral_ratio" :
config.asset_config[symbol]["maintenance_collateral_ratio"]
if (symbol in config.asset_config and "maintenance_collateral_ratio" in config.asset_config[symbol])
else config.asset_config["default"]["maintenance_collateral_ratio"],
"maximum_short_squeeze_ratio" :
config.asset_config[symbol]["maximum_short_squeeze_ratio"]
if (symbol in config.asset_config and "maximum_short_squeeze_ratio" in config.asset_config[symbol])
else config.asset_config["default"]["maximum_short_squeeze_ratio"],
"core_exchange_rate": {
"quote": {"asset_id": "1.3.0",
"amount": int(denominator_cer * (
config.asset_config[symbol]["core_exchange_factor"]
if (symbol in config.asset_config and "core_exchange_factor" in config.asset_config[symbol])
else config.asset_config["default"]["core_exchange_factor"]))
},
"base": {"asset_id": assets[asset]["id"],
"amount": numerator_cer
}}}
asset_update_required = publish_rule(rpc, asset)
if asset_update_required :
update_required = True
price_feeds[symbol] = {"asset_id": assets[asset]["id"],
"feed": price_feed,
"publish": asset_update_required
}
else :
print("Warning: Asset %s has a negative derived price of %f (%s metric)!" % (asset, float(derived_prices[asset][price_metric]), price_metric))
continue
if not debug :
# Print some stats ##########################################################
print_stats(price_feeds)
# Verify results or store them ##############################################
configStruct = {}
for key in dir(config) :
if key[0] == "_" :
continue
if key == "feedSources" :
continue
if key == "feedsources" :
continue
if key == "subprocess" :
continue
if key == "os" :
continue
configStruct[key] = config.__dict__[key]
# Store State
state["feed"] = feed
state["derived_prices"] = derived_prices
state["price_feeds"] = price_feeds
state["lastblock"] = get_last_block(rpc)
state["config"] = configStruct
blameFile = config.configPath + "/blame/" + str(state["lastblock"]) + ".json"
with open(blameFile, 'w') as fp:
json.dump(state, fp)
print("Blamefile: " + blameFile)
# Check publish rules and publich feeds #####################################
if update_required and not debug :
publish = False
if config.ask_confirmation :
if rpc._confirm("Are you SURE you would like to publish this feed?") :
publish = True
else :
publish = True
if publish :
print("Update required! Forcing now!")
update_feed(rpc, price_feeds)
else :
print("no update required")
else :
# Verify results
print()
print("[Warning] This script is loading old data for debugging. No price can be published.\n" +
" Please set 'blame' to 'latest' if you are ready to go online!")
print()
compare_feeds(state["derived_prices"], derived_prices)
from grapheneapi.grapheneapi import GrapheneAPI
import json
import random
import math
if __name__ == '__main__':
rpc = GrapheneAPI("localhost", 8092)
asset_symbol = "CNY"
producers = ["fakeusd-feed-producer"]
price = random.normalvariate(134, 0.1)
price = math.fabs(price)
asset = rpc.get_asset(asset_symbol)
base = rpc.get_asset("1.3.0")
price = price * 10**asset["precision"] / 10**base["precision"]
denominator = 1e5
numerator = round(price * 1e5)
for producer in producers:
account = rpc.get_account(producer)
price_feed = {
"settlement_price": {
"quote": {
"asset_id": "1.3.0",
"amount": denominator
},
"base": {
"asset_id": asset["id"],
perm = {}
perm["charge_market_fee"] = 0x01
perm["white_list"] = 0x02
perm["override_authority"] = 0x04
perm["transfer_restricted"] = 0x08
perm["disable_force_settle"] = 0x10
perm["global_settle"] = 0x20
perm["disable_confidential"] = 0x40
perm["witness_fed_asset"] = 0x80
perm["committee_fed_asset"] = 0x100
GRAPHENE_100_PERCENT = 10000
GRAPHENE_1_PERCENT = GRAPHENE_100_PERCENT / 100
if __name__ == '__main__':
rpc = GrapheneAPI("localhost", 8092)
issuer = "faucet"
symbol = "PEG.LAST" # LAST, RANDOM, PARITY
backing = "1.3.0"
account = rpc.get_account(issuer)
asset = rpc.get_asset(symbol)
permissions = {
"charge_market_fee": True,
"white_list": True,
"override_authority": True,
"transfer_restricted": True,
"disable_force_settle": True,
"global_settle": True,
from grapheneapi.grapheneapi import GrapheneAPI
from graphenebase.transactions import getOperationNameForId
import json
from deepdiff import DeepDiff
proposer = "xeroc"
expiration = "2016-01-21T22:59:59"
price_per_kbyte = 40 # in BTS
broadcast = False
if __name__ == '__main__':
graphene = GrapheneAPI("localhost", 8092)
obj = graphene.getObject("2.0.0")
current_fees = obj["parameters"]["current_fees"]["parameters"]
old_fees = obj["parameters"]["current_fees"]
scale = obj["parameters"]["current_fees"]["scale"] / 1e4
# General change of parameter
changes = {}
for f in current_fees:
if ("price_per_kbyte" in f[1]) and (f[1]["price_per_kbyte"] is 20):
print("Changing operation %s[%d]" % (getOperationNameForId(f[0]), f[0]))
changes[getOperationNameForId(f[0])] = f[1].copy()
changes[getOperationNameForId(f[0])]["price_per_kbyte"] = int(price_per_kbyte / scale * 1e5)
# overwrite / set specific fees
# changes["transfer"]["price_per_kbyte"] = int( 20 / scale * 1e5)
# changes["account_update"]["price_per_kbyte"] = int( 5 / scale * 1e5)
def main(rpchost, rpcport, expiration, broadcast, proposer):
rpc = GrapheneAPI(rpchost, rpcport)
obj = rpc.get_object("2.0.0")[0]
new_parameters = deepcopy(obj["parameters"])
current_fees = obj["parameters"]["current_fees"]["parameters"]
fees = obj["parameters"]["current_fees"]["parameters"]
scale = obj["parameters"]["current_fees"]["scale"] / 1e4
# General change of parameter
changes = {}
# Copy old fees
for f in current_fees:
changes[getOperationNameForId(f[0])] = f[1].copy()
# New fees
new_fee = {"fee": int(0.2 / scale * 1e5), "fee_per_day": int(0.2 / scale * 1e5)}
changes["htlc_create"] = new_fee
changes["htlc_redeem"] = new_fee
changes["htlc_extend"] = new_fee
tx = rpc.propose_fee_change(
proposer, formatTimeFromNow(expiration), changes, broadcast
)
op = tx["operations"][0][1]["proposed_ops"][0]["op"]
# New HTLC parameters are in extensions
op[1]["new_parameters"]["extensions"] = {
"updatable_htlc_options": {
"max_preimage_size": 19200,
"max_timeout_secs": 60 * 60 * 24 * 28,
}
}
ops = [op]
buildHandle = rpc.begin_builder_transaction()
for op in ops:
rpc.add_operation_to_builder_transaction(buildHandle, op)
rpc.set_fees_on_builder_transaction(buildHandle, "1.3.0")
params = rpc.get_object("2.0.0")[0]
preview = params["parameters"]["committee_proposal_review_period"] or 10
rpc.propose_builder_transaction2(
buildHandle, proposer, formatTimeFromNow(expiration), preview, False
)
rpc.set_fees_on_builder_transaction(buildHandle, "1.3.0")
# Sign and broadcast
tx = rpc.sign_builder_transaction(buildHandle, broadcast)
pprint(tx)
from grapheneapi.grapheneapi import GrapheneAPI
from bitshares.utils import formatTimeFromNow
import json
proposer = "xeroc"
expiration = formatTimeFromNow(10 * 60)
broadcast = True
if __name__ == "__main__":
graphene = GrapheneAPI("localhost", 8092)
obj = graphene.get_object("2.0.0")
# General change of parameter
changes = {"maximum_block_size": 2000000}
print("=" * 80)
tx = graphene.propose_parameter_change(proposer, expiration, changes,
broadcast)
print(json.dumps(tx, indent=4))
perm["global_settle"] = 0x20
perm["disable_confidential"] = 0x40
perm["witness_fed_asset"] = 0x80
perm["committee_fed_asset"] = 0x100
GRAPHENE_100_PERCENT = 10000
GRAPHENE_1_PERCENT = GRAPHENE_100_PERCENT / 100
class Config():
wallet_host = "localhost"
wallet_port = 8092
wallet_user = ""
wallet_password = ""
if __name__ == '__main__':
rpc = GrapheneAPI("localhost", 8092)
issuer = "xeroc"
symbol = "PMS"
backing = "1.3.0"
account = rpc.get_account(issuer)
asset = rpc.get_asset(backing)
permissions = {"charge_market_fee" : True,
"white_list" : True,
"override_authority" : True,
"transfer_restricted" : True,
"disable_force_settle" : True,
"global_settle" : True,
"disable_confidential" : True,
from deepdiff import DeepDiff
proposer = "cryptonomex-fabian"
expiration = "2016-03-29T19:25:00"
price_per_kbyte = 0
everythin_flat_fee = 0.1
broadcast = True
class Wallet():
wallet_host = "localhost"
wallet_port = 8092
if __name__ == '__main__':
rpc = GrapheneAPI("localhost", 8092)
obj = rpc.get_object("2.0.0")
current_fees = obj["parameters"]["current_fees"]["parameters"]
old_fees = obj["parameters"]["current_fees"]
scale = obj["parameters"]["current_fees"]["scale"] / 1e4
# General change of parameter
changes = {}
for f in current_fees:
if ("price_per_kbyte" in f[1] and f[1]["price_per_kbyte"] != 0):
print("Changing operation %s[%d]" %
(getOperationNameForId(f[0]), f[0]))
changes[getOperationNameForId(f[0])] = f[1].copy()
changes[getOperationNameForId(f[0])]["price_per_kbyte"] = int(
price_per_kbyte / scale * 1e5)
if ("fee" in f[1] and f[1]["fee"] != 0):