async def set_name(self, new_name: str):
cc_info: CCInfo = CCInfo(
self.cc_info.my_core,
self.cc_info.parent_info,
new_name,
)
await self.save_info(cc_info)
async def generate_new_coloured_coin(
self, amount: uint64) -> Optional[SpendBundle]:
coins = await self.standard_wallet.select_coins(amount)
if coins is None:
return None
origin = coins.copy().pop()
origin_id = origin.name()
cc_inner_hash = await self.get_new_inner_hash()
await self.add_lineage(origin_id, Program.to((0, [origin.as_list(),
0])))
genesis_coin_checker = create_genesis_or_zero_coin_checker(origin_id)
minted_cc_puzzle_hash = cc_puzzle_hash_for_inner_puzzle_hash(
CC_MOD, genesis_coin_checker, cc_inner_hash)
tx_record = await self.standard_wallet.generate_signed_transaction(
amount, minted_cc_puzzle_hash, uint64(0), origin_id, coins)
if tx_record is None:
return None
lineage_proof: Optional[Program] = lineage_proof_for_genesis(origin)
lineage_proofs = [(origin_id, lineage_proof)]
cc_info: CCInfo = CCInfo(genesis_coin_checker, lineage_proofs)
await self.save_info(cc_info)
return tx_record.spend_bundle
async def create_wallet_for_cc(wallet_state_manager: Any,
wallet: Wallet,
colour: str,
name: str = None):
self = CCWallet()
self.base_puzzle_program = None
self.base_inner_puzzle_hash = None
self.standard_wallet = wallet
if name:
self.log = logging.getLogger(name)
else:
self.log = logging.getLogger(__name__)
self.wallet_state_manager = wallet_state_manager
self.cc_info = CCInfo(cc_wallet_puzzles.cc_make_core(colour), [],
colour)
info_as_string = bytes(self.cc_info).hex()
self.wallet_info = await wallet_state_manager.user_store.create_wallet(
"CC Wallet", WalletType.COLOURED_COIN, info_as_string)
if self.wallet_info is None:
raise Exception("wallet_info is None")
await self.wallet_state_manager.add_new_wallet(self,
self.wallet_info.id)
return self
async def create_wallet_for_cc(
wallet_state_manager: Any,
wallet: Wallet,
genesis_checker_hex: str,
name: str = None,
):
self = CCWallet()
self.base_puzzle_program = None
self.base_inner_puzzle_hash = None
self.standard_wallet = wallet
if name:
self.log = logging.getLogger(name)
else:
self.log = logging.getLogger(__name__)
self.wallet_state_manager = wallet_state_manager
self.cc_info = CCInfo(
Program.from_bytes(bytes.fromhex(genesis_checker_hex)), [])
info_as_string = bytes(self.cc_info).hex()
self.wallet_info = await wallet_state_manager.user_store.create_wallet(
"CC Wallet", WalletType.COLOURED_COIN.value, info_as_string)
if self.wallet_info is None:
raise Exception("wallet_info is None")
await self.wallet_state_manager.add_new_wallet(self,
self.wallet_info.id)
return self
async def add_parent(self, name: bytes32, parent: Optional[CCParent]):
self.log.info(f"Adding parent {name}: {parent}")
current_list = self.cc_info.parent_info.copy()
current_list.append((name, parent))
cc_info: CCInfo = CCInfo(
self.cc_info.my_core, current_list, self.cc_info.my_colour_name,
)
await self.save_info(cc_info)
async def create(
wallet_state_manager: Any,
wallet: Wallet,
wallet_info: WalletInfo,
) -> CCWallet:
self = CCWallet()
self.log = logging.getLogger(__name__)
self.wallet_state_manager = wallet_state_manager
self.wallet_info = wallet_info
self.standard_wallet = wallet
self.cc_info = CCInfo.from_bytes(hexstr_to_bytes(self.wallet_info.data))
self.base_puzzle_program = None
self.base_inner_puzzle_hash = None
return self
async def generate_new_coloured_coin(self, amount: uint64) -> Optional[SpendBundle]:
coins = await self.standard_wallet.select_coins(amount)
if coins is None:
return None
origin = coins.copy().pop()
origin_id = origin.name()
# self.add_parent(origin_id, origin_id)
cc_core = cc_wallet_puzzles.cc_make_core(origin_id)
parent_info = {}
parent_info[origin_id] = (
origin.parent_coin_info,
origin.puzzle_hash,
origin.amount,
)
cc_info: CCInfo = CCInfo(cc_core, [], origin_id.hex())
await self.save_info(cc_info)
cc_inner = await self.get_new_inner_hash()
cc_puzzle = cc_wallet_puzzles.cc_make_puzzle(cc_inner, cc_core)
cc_puzzle_hash = cc_puzzle.get_tree_hash()
tx_record: Optional[
TransactionRecord
] = await self.standard_wallet.generate_signed_transaction(
amount, cc_puzzle_hash, uint64(0), origin_id, coins
)
self.log.warning(f"cc_puzzle_hash is {cc_puzzle_hash}")
eve_coin = Coin(origin_id, cc_puzzle_hash, amount)
if tx_record is None or tx_record.spend_bundle is None:
return None
eve_spend = cc_generate_eve_spend(eve_coin, cc_puzzle)
full_spend = SpendBundle.aggregate([tx_record.spend_bundle, eve_spend])
return full_spend
async def create_new_cc(
wallet_state_manager: Any,
wallet: Wallet,
amount: uint64,
name: str = None,
):
self = CCWallet()
self.base_puzzle_program = None
self.base_inner_puzzle_hash = None
self.standard_wallet = wallet
if name:
self.log = logging.getLogger(name)
else:
self.log = logging.getLogger(__name__)
self.wallet_state_manager = wallet_state_manager
self.cc_info = CCInfo(None, [], None)
info_as_string = bytes(self.cc_info).hex()
self.wallet_info = await wallet_state_manager.user_store.create_wallet(
"CC Wallet", WalletType.COLOURED_COIN, info_as_string)
if self.wallet_info is None:
raise ValueError("Internal Error")
spend_bundle = await self.generate_new_coloured_coin(amount)
if spend_bundle is None:
await wallet_state_manager.user_store.delete_wallet(
self.wallet_info.id)
raise ValueError(
"Internal Error, unable to generate new coloured coin")
await self.wallet_state_manager.add_new_wallet(self,
self.wallet_info.id)
# Change and actual coloured coin
non_ephemeral_spends: List[
Coin] = spend_bundle.not_ephemeral_additions()
cc_coin = None
puzzle_store = self.wallet_state_manager.puzzle_store
for c in non_ephemeral_spends:
info = await puzzle_store.wallet_info_for_puzzle_hash(c.puzzle_hash
)
if info is None:
raise ValueError("Internal Error")
id, wallet_type = info
if id == self.wallet_info.id:
cc_coin = c
if cc_coin is None:
raise ValueError(
"Internal Error, unable to generate new coloured coin")
regular_record = TransactionRecord(
confirmed_at_index=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=cc_coin.puzzle_hash,
amount=uint64(cc_coin.amount),
fee_amount=uint64(0),
incoming=False,
confirmed=False,
sent=uint32(0),
spend_bundle=spend_bundle,
additions=spend_bundle.additions(),
removals=spend_bundle.removals(),
wallet_id=self.wallet_state_manager.main_wallet.wallet_info.id,
sent_to=[],
trade_id=None,
)
cc_record = TransactionRecord(
confirmed_at_index=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=cc_coin.puzzle_hash,
amount=uint64(cc_coin.amount),
fee_amount=uint64(0),
incoming=True,
confirmed=False,
sent=uint32(10),
spend_bundle=None,
additions=spend_bundle.additions(),
removals=spend_bundle.removals(),
wallet_id=self.wallet_info.id,
sent_to=[],
trade_id=None,
)
await self.standard_wallet.push_transaction(regular_record)
await self.standard_wallet.push_transaction(cc_record)
return self
async def add_lineage(self, name: bytes32, lineage: Optional[Program]):
self.log.info(f"Adding parent {name}: {lineage}")
current_list = self.cc_info.lineage_proofs.copy()
current_list.append((name, lineage))
cc_info: CCInfo = CCInfo(self.cc_info.my_genesis_checker, current_list)
await self.save_info(cc_info)