def signature_for_solution(self, solution):
signatures = []
conditions_dict = conditions_by_opcode(conditions_for_solution(solution))
for _ in hash_key_pairs_for_conditions_dict(conditions_dict):
signature = self.sign(_)
signatures.append(signature)
return BLSSignature.aggregate(signatures)
def generate_recovery_transaction(self, coins, root_public_key, secret_key,
escrow_duration):
recovery_pubkey = root_public_key.public_child(
0).get_public_key().serialize()
signatures = []
coin_solutions = []
secret_key = BLSPrivateKey(secret_key)
for coin in coins:
pubkey = self.find_pubkey_for_escrow_puzzle(
coin, root_public_key, escrow_duration)
puzzle = self.get_escrow_puzzle_with_params(
recovery_pubkey, pubkey.serialize(), escrow_duration)
op_create_coin = ConditionOpcode.CREATE_COIN[0]
puzzlehash = f'0x' + str(hexbytes(self.get_new_puzzlehash()))
solution_src = sexp(
quote(sexp(sexp(op_create_coin, puzzlehash, coin.amount))),
sexp(), 1)
solution = Program(binutils.assemble(solution_src))
puzzle_solution_list = clvm.to_sexp_f([puzzle, solution])
coin_solution = CoinSolution(coin, puzzle_solution_list)
coin_solutions.append(coin_solution)
conditions_dict = conditions_by_opcode(
conditions_for_solution(puzzle_solution_list))
for _ in hash_key_pairs_for_conditions_dict(conditions_dict):
signature = secret_key.sign(_.message_hash)
signatures.append(signature)
coin_solution_list = CoinSolutionList(coin_solutions)
aggsig = BLSSignature.aggregate(signatures)
spend_bundle = SpendBundle(coin_solution_list, aggsig)
return spend_bundle
def sign_transaction(self, spends: (Program, [CoinSolution])):
sigs = []
for puzzle, solution in spends:
pubkey, secretkey = self.get_keys(solution.coin.puzzle_hash)
code_ = [puzzle, solution.solution]
sexp = clvm.to_sexp_f(code_)
conditions_dict = conditions_by_opcode(
conditions_for_solution(sexp))
for _ in hash_key_pairs_for_conditions_dict(conditions_dict):
signature = secretkey.sign(_.message_hash)
sigs.append(signature)
aggsig = BLSSignature.aggregate(sigs)
solution_list = CoinSolutionList(
[CoinSolution(coin_solution.coin, clvm.to_sexp_f([puzzle, coin_solution.solution])) for
(puzzle, coin_solution) in spends])
spend_bundle = SpendBundle(solution_list, aggsig)
return spend_bundle
def test_1():
puzzle_program_0 = puzzle_program_for_index(0)
puzzle_program_1 = puzzle_program_for_index(1)
puzzle_program_2 = puzzle_program_for_index(2)
conditions = [make_create_coin_condition(std_hash(bytes(pp)), amount) for pp, amount in [
(puzzle_program_1, 1000), (puzzle_program_2, 2000),
]]
puzzle_hash_solution = p2_delegated_puzzle.solution_for_conditions(puzzle_program_0, conditions)
output_conditions = conditions_for_solution(puzzle_hash_solution)
from pprint import pprint
output_conditions_dict = conditions_by_opcode(output_conditions)
pprint(output_conditions_dict)
input_coin_info_hash = bytes([0] * 32)
additions = created_outputs_for_conditions_dict(output_conditions_dict, input_coin_info_hash)
print(additions)
assert len(additions) == 2
def conditions_dict(self):
from chiasim.validation.Conditions import conditions_by_opcode
return conditions_by_opcode(self.conditions())