def test_transfer_2of2_serialized_deserialized(self): # Send a 2 of 2 transaction from beem5 which needs beem4's cosign to send # funds but sign the transaction with beem5's key and then serialize the transaction # and deserialize the transaction. After that, sign with beem4's key. steem = self.bts steem.nobroadcast = False steem.wallet.unlock("123") # steem.wallet.removeAccount("beem4") steem.wallet.removePrivateKeyFromPublicKey(str(PublicKey(self.active_private_key_of_beem4, prefix=core_unit))) tx = TransactionBuilder(use_condenser_api=True, steem_instance=steem) tx.appendOps(Transfer(**{"from": 'beem5', "to": 'beem1', "amount": Amount("0.01 STEEM", steem_instance=steem), "memo": '2 of 2 serialized/deserialized transaction'})) tx.appendSigner("beem5", "active") tx.addSigningInformation("beem5", "active") tx.sign() tx.clearWifs() self.assertEqual(len(tx['signatures']), 1) # steem.wallet.removeAccount("beem5") steem.wallet.removePrivateKeyFromPublicKey(str(PublicKey(self.active_private_key_of_beem5, prefix=core_unit))) tx_json = tx.json() del tx new_tx = TransactionBuilder(tx=tx_json, steem_instance=steem) self.assertEqual(len(new_tx['signatures']), 1) steem.wallet.addPrivateKey(self.active_private_key_of_beem4) new_tx.appendMissingSignatures() new_tx.sign(reconstruct_tx=False) self.assertEqual(len(new_tx['signatures']), 2) new_tx.broadcast() steem.nobroadcast = True
def test_transfer_2of2_serialized_deserialized(self): # Send a 2 of 2 transaction from elf which needs steemfiles's cosign to send # funds but sign the transaction with elf's key and then serialize the transaction # and deserialize the transaction. After that, sign with steemfiles's key. steem = self.bts steem.nobroadcast = False steem.wallet.unlock("123") steem.wallet.removeAccount("steemfiles") tx = TransactionBuilder(steem_instance=steem) tx.appendOps( Transfer( **{ "from": 'elf', "to": 'leprechaun', "amount": '0.01 SBD', "memo": '2 of 2 serialized/deserialized transaction' })) tx.appendSigner("elf", "active") tx.addSigningInformation("elf", "active") tx.sign() tx.clearWifs() self.assertEqual(len(tx['signatures']), 1) steem.wallet.removeAccount("elf") tx_json = tx.json() del tx new_tx = TransactionBuilder(tx=tx_json, steem_instance=steem) self.assertEqual(len(new_tx['signatures']), 1) steem.wallet.addPrivateKey(self.active_private_key_of_steemfiles) new_tx.appendMissingSignatures() new_tx.sign(reconstruct_tx=False) self.assertEqual(len(new_tx['signatures']), 2) new_tx.broadcast() steem.nobroadcast = True
def test_transfer_2of2_wif(self): # Send a 2 of 2 transaction from elf which needs steemfiles's cosign to send # funds but sign the transaction with elf's key and then serialize the transaction # and deserialize the transaction. After that, sign with steemfiles's key. steem = Steem(node=["wss://testnet.steem.vc"], num_retries=10, keys=[self.active_private_key_of_elf]) tx = TransactionBuilder(steem_instance=steem) tx.appendOps( Transfer( **{ "from": 'elf', "to": 'leprechaun', "amount": '0.01 SBD', "memo": '2 of 2 serialized/deserialized transaction' })) tx.appendSigner("elf", "active") tx.addSigningInformation("elf", "active") tx.sign() tx.clearWifs() self.assertEqual(len(tx['signatures']), 1) tx_json = tx.json() del steem del tx steem = Steem(node=["wss://testnet.steem.vc"], num_retries=10, keys=[self.active_private_key_of_steemfiles]) new_tx = TransactionBuilder(tx=tx_json, steem_instance=steem) new_tx.appendMissingSignatures() new_tx.sign(reconstruct_tx=False) self.assertEqual(len(new_tx['signatures']), 2) new_tx.broadcast()
def test_transfer_2of2_offline(self): # Send a 2 of 2 transaction from beem5 which needs beem4's cosign to send # funds but sign the transaction with beem5's key and then serialize the transaction # and deserialize the transaction. After that, sign with beem4's key. steem = self.bts steem.nobroadcast = False steem.wallet.unlock("123") steem.wallet.removeAccount("beem4") tx = TransactionBuilder(steem_instance=steem) tx.appendOps( Transfer( **{ "from": 'beem5', "to": 'beem', "amount": '0.01 SBD', "memo": '2 of 2 serialized/deserialized transaction' })) tx.appendSigner("beem5", "active") tx.addSigningInformation("beem5", "active") tx.sign() tx.clearWifs() self.assertEqual(len(tx['signatures']), 1) steem.wallet.removeAccount("beem5") steem.wallet.addPrivateKey(self.active_private_key_of_beem4) tx.appendMissingSignatures() tx.sign(reconstruct_tx=False) self.assertEqual(len(tx['signatures']), 2) tx.broadcast() steem.nobroadcast = True steem.wallet.addPrivateKey(self.active_private_key_of_beem5)
def request_recovery(account): """ Request the recovery of ACCOUNT. This action has to be initiated/signed by the recovery partner of ACCOUNT. """ acc = Account(account) if acc.get_owner_history() == []: logger.error("The owner key of @%s was not changed within " "the last 30 days - recovering this account is " "not possible!" % (acc['name'])) return # Ask and verify the new pubkey for the to-be-recovered account new_owner_key = input("Enter new PUBLIC owner key for @%s: " % (acc['name'])) # PublicKey call to make sure it is a valid public key pk_validity_check = PublicKey(new_owner_key, prefix=acc.steem.prefix) if format(pk_validity_check, acc.steem.prefix) != new_owner_key: raise ValueError("Invalid public owner key!") # Ask and verify the active key of the recovery account recovery_ak = getpass("Enter active key, owner key or master " "password for @%s: " % (acc['recovery_account'])) recovery_ak = passwordkey_to_key(recovery_ak, acc['recovery_account'], "active", prefix=acc.steem.prefix) # Assemble the account recovery request operation new_owner_authority = { 'key_auths': [[new_owner_key, 1]], 'account_auths': [], 'weight_threshold': 1, 'prefix': acc.steem.prefix } op = operations.Request_account_recovery( **{ 'account_to_recover': acc['name'], 'recovery_account': acc['recovery_account'], 'new_owner_authority': new_owner_authority, 'extensions': [], 'prefix': acc.steem.prefix }) # Send the operation to the blockchain tb = TransactionBuilder(steem_instance=acc.steem) tb.appendOps([op]) tb.appendWif(recovery_ak) tb.sign() tb.broadcast() logger.info("@%s requested account recovery for @%s:" % (acc['recovery_account'], acc['name']))
def test_Transfer_broadcast(self): nodelist = NodeList() stm = Steem(node=self.nodes, keys=[self.active_key], nobroadcast=True, expiration=120, num_retries=10) tx = TransactionBuilder(use_condenser_api=True, expiration=10, steem_instance=stm) tx.appendOps(Transfer(**{"from": "beem", "to": "beem1", "amount": Amount("1 STEEM", steem_instance=stm), "memo": ""})) tx.appendSigner("beem", "active") tx.sign() tx.broadcast()
def check_post(self): com = dict() com = { 'parent_author': '', 'parent_permlink': 'steem', 'author': 'me', 'permlink': 'testpost', 'title': 'testpost pls ignore', 'body': 'do not upvote', 'json_metadata': { 'tags': ('test', 'post', 'pls', 'ignore', 'steem'), } } print(len(com['body'])) tx = TransactionBuilder(steem_instance=self.stm) tx.appendOps(Comment(com)) tx.appendSigner("petertag", "active") signed_tx = tx.sign() sz = getsizeof(com) pprint(com) pprint(signed_tx) print("Size is %i" % sz) self.compute_cost(type=1, tx_size=sz, perm_len=len(com['permlink']), pperm_len=len(com['parent_permlink'])) broadcast_tx = tx.broadcast() pprint(broadcast_tx)
def test_Transfer_broadcast_appbase(self): stm = Steem(node=get_node_list(appbase=True), keys=[wif], num_retries=10) tx = TransactionBuilder(expiration=10, steem_instance=stm) tx.appendOps( Transfer( **{ "from": "test", "to": "test1", "amount": Amount("1 STEEM", steem_instance=stm), "memo": "" })) tx.appendSigner("test", "active") tx.sign() with self.assertRaises(exceptions.MissingRequiredActiveAuthority): tx.broadcast()
def test_transfer_2of2_simple(self): # Send a 2 of 2 transaction from elf which needs beem4's cosign to send funds steem = self.bts steem.nobroadcast = False tx = TransactionBuilder(use_condenser_api=True, steem_instance=steem) tx.appendOps(Transfer(**{"from": 'beem5', "to": 'beem1', "amount": Amount("0.01 STEEM", steem_instance=steem), "memo": '2 of 2 simple transaction'})) tx.appendWif(self.active_private_key_of_beem5) tx.sign() tx.clearWifs() tx.appendWif(self.active_private_key_of_beem4) tx.sign(reconstruct_tx=False) self.assertEqual(len(tx['signatures']), 2) tx.broadcast() steem.nobroadcast = True
def test_transfer_1of1(self): steem = self.bts steem.nobroadcast = False tx = TransactionBuilder(use_condenser_api=True, steem_instance=steem) tx.appendOps(Transfer(**{"from": 'beem', "to": 'beem1', "amount": Amount("0.01 STEEM", steem_instance=steem), "memo": '1 of 1 transaction'})) self.assertEqual( tx["operations"][0]["type"], "transfer_operation" ) tx.appendWif(self.active_key) tx.sign() tx.sign() self.assertEqual(len(tx['signatures']), 1) tx.broadcast() steem.nobroadcast = True
def test_transfer_2of2_wallet(self): # Send a 2 of 2 transaction from beem5 which needs beem4's cosign to send # priv key of beem5 and beem4 are stored in the wallet # appendSigner fetches both keys and signs automatically with both keys. steem = self.bts steem.nobroadcast = False steem.wallet.unlock("123") tx = TransactionBuilder(use_condenser_api=True, steem_instance=steem) tx.appendOps(Transfer(**{"from": 'beem5', "to": 'beem1', "amount": Amount("0.01 STEEM", steem_instance=steem), "memo": '2 of 2 serialized/deserialized transaction'})) tx.appendSigner("beem5", "active") tx.sign() self.assertEqual(len(tx['signatures']), 2) tx.broadcast() steem.nobroadcast = True
def test_transfer_1of1(self): steem = self.bts steem.nobroadcast = False tx = TransactionBuilder(steem_instance=steem) tx.appendOps( Transfer( **{ "from": 'beem', "to": 'leprechaun', "amount": '0.01 SBD', "memo": '1 of 1 transaction' })) self.assertEqual(tx["operations"][0][0], "transfer") tx.appendWif(self.active_key) tx.sign() tx.sign() self.assertEqual(len(tx['signatures']), 1) tx.broadcast() steem.nobroadcast = True
def test_transfer_2of2_wif(self): nodelist = NodeList() # Send a 2 of 2 transaction from elf which needs beem4's cosign to send # funds but sign the transaction with elf's key and then serialize the transaction # and deserialize the transaction. After that, sign with beem4's key. steem = Steem( node=self.nodes, num_retries=10, keys=[self.active_private_key_of_beem5], expiration=360, ) tx = TransactionBuilder(use_condenser_api=True, steem_instance=steem) tx.appendOps( Transfer( **{ "from": 'beem5', "to": 'beem', "amount": Amount("0.01 STEEM", steem_instance=steem), "memo": '2 of 2 serialized/deserialized transaction' })) tx.appendSigner("beem5", "active") tx.addSigningInformation("beem5", "active") tx.sign() tx.clearWifs() self.assertEqual(len(tx['signatures']), 1) tx_json = tx.json() del steem del tx steem = Steem( node=self.nodes, num_retries=10, keys=[self.active_private_key_of_beem4], expiration=360, ) new_tx = TransactionBuilder(tx=tx_json, steem_instance=steem) new_tx.appendMissingSignatures() new_tx.sign(reconstruct_tx=False) self.assertEqual(len(new_tx['signatures']), 2) new_tx.broadcast()
def test_transfer_2of2_simple(self): # Send a 2 of 2 transaction from elf which needs steemfiles's cosign to send funds steem = self.bts steem.nobroadcast = False tx = TransactionBuilder(steem_instance=steem) tx.appendOps( Transfer( **{ "from": 'elf', "to": 'leprechaun', "amount": '0.01 SBD', "memo": '2 of 2 simple transaction' })) tx.appendWif(self.active_private_key_of_elf) tx.sign() tx.clearWifs() tx.appendWif(self.active_private_key_of_steemfiles) tx.sign(reconstruct_tx=False) self.assertEqual(len(tx['signatures']), 2) tx.broadcast() steem.nobroadcast = True
def test_post(wls): op1 = operations.Social_action( **{ "account": "guest123", "social_action_comment_create": { "permlink": 'just-a-test-post', "parent_author": "", "parent_permlink": "test", "title": "just a test post", "body": "test post body", "json_metadata": '{"app":"wls_python"}' } }) op2 = operations.Social_action( **{ "account": "guest123", "social_action_comment_update": { "permlink": 'just-a-test-post', "title": "just a test post", "body": "test post body", } }) op3 = operations.Vote( **{ 'voter': 'guest123', 'author': 'wlsuser', 'permlink': 'another-test-post', 'weight': 10000, }) privateWif = "5K..." tx = TransactionBuilder(use_condenser_api=True, steem_instance=wls) tx.appendOps(op1) tx.appendWif(privateWif) tx.sign() tx.broadcast()
def test_transfer_2of2_wallet(self): # Send a 2 of 2 transaction from elf which needs steemfiles's cosign to send # priv key of elf and steemfiles are stored in the wallet # appendSigner fetches both keys and signs automatically with both keys. steem = self.bts steem.nobroadcast = False steem.wallet.unlock("123") tx = TransactionBuilder(steem_instance=steem) tx.appendOps( Transfer( **{ "from": 'elf', "to": 'leprechaun', "amount": '0.01 SBD', "memo": '2 of 2 serialized/deserialized transaction' })) tx.appendSigner("elf", "active") tx.sign() self.assertEqual(len(tx['signatures']), 2) tx.broadcast() steem.nobroadcast = True
'account_auths': acc['posting']['account_auths'], 'key_auths': [[key_auths_public['posting'], 1]], "address_auths": [], 'weight_threshold': 1 }, 'memo_key': key_auths_public['memo'], "json_metadata": acc['json_metadata'], "prefix": prefix, }) ops = [op] tb = TransactionBuilder() tb.appendOps(ops) tb.appendWif(wif) tb.sign() output = tb.broadcast() data = { "name": acc['name'], "wif": new_password, "owner": [{ "type": "public", "value": key_auths_public["owner"] }, { "type": "private", "value": key_auths_private["owner"] }], "active": [{ "type": "public",
print("broadcast voter %s votes %s" % (vote["voter"], vote["authorperm"])) author, permlink = resolve_authorperm(vote["authorperm"]) op = operations.Vote(**{"voter": vote["voter"], "author": author, "permlink": permlink, "weight": int(vote["weight"] * 100)}) ops.append(op) broadcasted_votes.append(vote) if len(ops) > 5: try: print("Broadcasting %d votes" % len(ops)) tx.appendOps(ops) # tx.appendMissingSignatures() tx.appendSigner("rewarding", "posting") tx.sign() reply_message = tx.broadcast() # print(reply_message) ops = [] #if vote["trail_vote"]: # print("trail voter %s votes %s" % (vote["voter"], vote["authorperm"])) #else: # print("voter %s votes %s after %.2f min (%.2f min)" % (vote["voter"], vote["authorperm"], age_min, vote["vote_delay_min"])) # reply_message = stm.vote(vote["weight"], vote["authorperm"], vote["voter"]) # vote_count += 1 expiration = formatTimeString(reply_message["expiration"]).replace(tzinfo=None) except Exception as e: expiration = datetime.utcnow() print("Vote failed: %s" % str(e)) for vote in broadcasted_votes: try: reply_message = stm.vote(vote["weight"], vote["authorperm"], vote["voter"])
s = Steem(node=['https://api.steemit.com'], keys=[recovery_account_private_key]) op_recover_account = beembase.operations.Recover_account( **op_recover_account_data) print('op_recover_account') print(op_recover_account) tb = TransactionBuilder() tb.appendOps([op_recover_account]) tb.appendWif(str(old_account_owner_private_key)) tb.appendWif(str(new_account_owner_private_key)) tb.sign() result = tb.broadcast() print('result') print(result) #update account keys initialisation and transmission s = Steem(node=['https://api.steemit.com'], keys=[new_account_owner_private_key]) op_account_update = beembase.operations.Account_update( **op_account_update_data) print('op_account_update') print(op_account_update) tb = TransactionBuilder() tb.appendOps([op_account_update])
tx = TransactionBuilder(hive_instance=node_client) ops = [] op = operations.Comment_options(**{ 'author' : accounts[0]['name'], 'permlink' : "hivepy-proposal-title-{}".format(accounts[0]['name']), 'max_accepted_payout' : '1000.000 TBD', 'percent_steem_dollars' : 5000, 'allow_votes' : True, 'allow_curation_rewards' : True, 'prefix': node_client.prefix }) ops.append(op) tx.appendOps(ops) tx.appendWif(accounts[0]['private_key']) tx.sign() tx.broadcast() logger.exception( "Expected exception for old style op was not thrown" ) except Exception as ex: if str(ex) == "Assert Exception:false: Obsolete form of transaction detected, update your wallet.": logger.info("Expected exception on old style op: {}".format(ex)) exit_code = 0 else: logger.info("Unexpected exception on old style op: {}".format(ex)) hive_utils.common.wait_n_blocks(node_client.rpc.url, 5) # use hybrid op with new keys logger.info("Using hybrid op with new keys") try: tx = TransactionBuilder(hive_instance=node_client) ops = []
def recover_account(account): """Recover ACCOUNT. This action has to be initiated/signed by the account to be recovered. """ acc = Account(account) if acc.get_owner_history() == []: logger.error("@%s has an empty owner history - recovering " "this account is not possible!" % (acc['name'])) return # ask & verify the old owner key old_priv_owner_key = getpass("Enter the old master password or owner " "key for @%s: " % (acc['name'])) old_pk = passwordkey_to_key(old_priv_owner_key, acc['name'], role="owner", prefix=acc.steem.prefix) old_public_owner_key = format(old_pk.get_public(), acc.steem.prefix) # get the new password to prepare all new keys new_pwd = getpass("Enter the new master password for @%s: " % (acc['name'])) key_auths = {} for role in ['owner', 'active', 'posting', 'memo']: pk = PasswordKey(acc['name'], new_pwd, role=role) key_auths[role] = format(pk.get_public_key(), acc.steem.prefix) if role == 'owner': new_priv_owner_key = str(pk.get_private()) # Assemble the account recovery operation recent_owner_authority = { "key_auths": [[old_public_owner_key, 1]], "account_auths": [], "weight_threshold": 1, "prefix": acc.steem.prefix } new_owner_authority = { "key_auths": [[key_auths['owner'], 1]], "account_auths": [], "weight_threshold": 1, "prefix": acc.steem.prefix } op = operations.Recover_account( **{ 'account_to_recover': acc['name'], 'new_owner_authority': new_owner_authority, 'recent_owner_authority': recent_owner_authority, 'extensions': [], "prefix": acc.steem.prefix }) # Send the recovery operations to the blockchain tb = TransactionBuilder(steem_instance=acc.steem) tb.appendOps([op]) tb.appendWif(new_priv_owner_key) tb.appendWif(old_priv_owner_key) tb.sign() tb.broadcast() logger.info("@%s recovered." % (acc['name'])) # Assemble the account update operation op = operations.Account_update( **{ "account": acc["name"], 'active': { 'account_auths': [], 'key_auths': [[key_auths['active'], 1]], "address_auths": [], 'weight_threshold': 1, 'prefix': acc.steem.prefix }, 'posting': { 'account_auths': acc['posting']['account_auths'], 'key_auths': [[key_auths['posting'], 1]], "address_auths": [], 'weight_threshold': 1, 'prefix': acc.steem.prefix }, 'memo_key': key_auths['memo'], "json_metadata": acc['json_metadata'], "prefix": acc.steem.prefix }) # Send the recovery operations to the blockchain tb = TransactionBuilder(steem_instance=acc.steem) tb.appendOps([op]) tb.appendWif(new_priv_owner_key) tb.sign() tb.broadcast() logger.info("SUCCESS: @%s's active, posting and memo keys updated." % (acc['name']))
# Make transaction and broadcast: tx = TransactionBuilder(blockchain_instance=hive) tx.appendOps( Vote( **{ "voter": account, "author": h.author, "permlink": h.permlink, "weight": int(float(weight) * 100) })) tx.appendWif(pkey) signed_tx = tx.sign() if not dryrun: broadcast_tx = tx.broadcast(trx_id=True) votado = True votos.append({ "time": datetime.datetime.now(), "permlink": h.permlink, "author": h.author, "rewards": float(h.reward) }) # Update and save script state with open("state.pickle", "wb") as f: state["votos"] = votos state["last_called"] = datetime.datetime.now() pickle.dump(state, f)
"owner": ACCT, "url": "No website yet", "block_signing_key": NATIVE_PREFIX + '1111111111111111111111111111111114T1Anm', "props": { "account_creation_fee": Amount("0.100 %s" % (NATIVE_SYMBOL)), "maximum_block_size":131072, }, "fee": Amount("0.000 %s" % (NATIVE_SYMBOL)), "prefix": NATIVE_PREFIX, } op = operations.Witness_update(**update_witness) tx.appendOps(op) #tx.appendSigner(ACCT, "active") tx.appendWif(WIF) signed_tx = tx.sign() broadcast_tx = tx.broadcast() status_logger.logger.warning("Total missed at or above threshold. Disabling witness server. \nOperation: " + json.dumps(broadcast_tx, indent=4)) sys.exit() else: status_logger.logger.info("Witness " + ACCT + " current total missed: " + str(total_missed) + "\nWitness server operational\n--------------------------") time.sleep(60) #Pause script for 60 seconds. except KeyboardInterrupt: sys.exit() except Exception as WitnessDoesNotExistsException: status_logger.logger.exception("Exception occured\n") status_logger.logger.info("Reconnecting...") stm = Steem( node=["https://peer.vit.tube/"], bundle=True, blocking="head", nobroadcast=NO_BROADCAST, #set True for testing
try: c.refresh() except ContentDoesNotExistsException: continue c_list[c.permlink] = 1 if not c.is_comment(): counter += 1 if voter not in c.get_votes() and c.time_elapsed() > timedelta( minutes=wait) and c.time_elapsed() < timedelta(hours=2): op = operations.Vote( **{ "voter": voter, "author": c.author, "permlink": c.permlink, "weight": int(percent * 100) }) ops = [] ops.append(op) stm.wallet.unlock(wallet_pw) tx = TransactionBuilder(steem_instance=stm) tx.appendOps(ops) tx.appendSigner(signer, 'posting') tx.sign() returncode = tx.broadcast() print(returncode) voter_vp -= percent * 2 / 100 if counter > 10 or voter_vp < min_vp or c.time_elapsed() > timedelta( hours=2): # going back 10 entries should be enough (50 minutes, on a spamming account e.g.) break