def issue(self, amount, to, memo=None, **kwargs): """ Issue new shares of an asset :param float amount: Amount to issue :param str to: Recipient :param str memo: (optional) Memo message """ from .memo import Memo from .account import Account to = Account(to) account = Account(self["issuer"]) memoObj = Memo(from_account=account, to_account=to, blockchain_instance=self) # append operation op = operations.Asset_issue( **{ "fee": { "amount": 0, "asset_id": "1.3.0", }, # Will be filled in automatically "issuer": account["id"], # the Issuer account "asset_to_issue": { "amount": int(amount * 10**self["precision"]), "asset_id": self["id"], }, "issue_to_account": to["id"], "memo": memoObj.encrypt(memo), "extensions": [], }) return self.exbet.finalizeOp(op, self["issuer"], "active", **kwargs)
def test_asset_issue(self): message = "abcdefgABCDEFG0123456789" nonce = "5862723643998573708" pub = format(account.PrivateKey(wif).pubkey, prefix) encrypted_memo = memo.encode_memo( account.PrivateKey(wif), account.PublicKey(pub, prefix=prefix), nonce, message, ) self.op = operations.Asset_issue( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "issuer": "1.2.0", "asset_to_issue": { "amount": 0, "asset_id": "1.3.0" }, "memo": { "from": pub, "to": pub, "nonce": nonce, "message": encrypted_memo, }, "issue_to_account": "1.2.0", "extensions": [], "prefix": prefix, }) self.cm = ("f68585abf4dce7c80457010e000000000000000000000000000" "00000000000000102c0ded2bc1f1305fb0faac5e6c03ee3a192" "4234985427b6167ca569d13df435cf02c0ded2bc1f1305fb0fa" "ac5e6c03ee3a1924234985427b6167ca569d13df435cf8c94d1" "9817945c5120fa5b6e83079a878e499e2e52a76a7739e9de409" "86a8e3bd8a68ce316cee50b210000012055139900ea2ae7db9d" "4ef0d5d4015d2d993d0590ad32662bda94daba74a5e13411aef" "4de6f847e9e4300e5c8c36aa8e5f9032d25fd8ca01abd58c7e9" "528677e4") self.doit()
def issue_asset(inst, issue_to_account, to_issue_asset, amount, memo=None, account=None, **kwargs): """ issue_asset :param str account: the account to cancel to (defaults to ``default_account``) """ if not account: if "default_account" in inst.config: account = inst.config["default_account"] if not account: raise ValueError("You need to provide an account") account = Account(account) if 'extensions' in kwargs: extensions = kwargs['extensions'] else: extensions = Set([]) print(extensions) asset_to_issue = {"amount": amount, "asset_id": to_issue_asset} kwargs = { 'fee': { "amount": 0, "asset_id": "1.3.0" }, 'issuer': account["id"], 'asset_to_issue': asset_to_issue, 'issue_to_account': issue_to_account, 'memo': memo, 'extensions': extensions } op = operations.Asset_issue(**kwargs) return inst.finalizeOp(op, account, "active")
def issue(self, amount: Decimal, address: str, memo: str = None, trigger_data=None) -> dict: """ Issue (create/print) tokens to a given address/account, optionally specifying a memo if desired. The network transaction fee for issuance will be paid by the issuing account in BTS. Example - Issue 5.10 SGTK to @privex >>> s = BitsharesManager('SGTK') >>> s.issue(address='privex', amount=Decimal('5.10')) :param Decimal amount: Amount of tokens to issue, as a Decimal :param address: Account to issue the tokens to (which is also the issuer account) :param memo: Optional memo for the issuance transaction :raises IssuerKeyError: Cannot issue because we don't have authority to (missing key etc.) :raises TokenNotFound: When the requested token `symbol` does not exist :raises AccountNotFound: The requested account doesn't exist :raises ArithmeticError: When the amount is lower than the lowest amount allowed by the token's precision :return dict: Result Information Format:: { txid:str - Transaction ID - None if not known, coin:str - Symbol that was sent, amount:Decimal - The amount that was issued, fee:Decimal - TX Fee that was taken from the amount (will be 0 if fee is in BTS rather than the issuing token), from:str - The account/address the coins were issued from, send_type:str - Should be statically set to "issue" } """ asset_obj = self.get_asset_obj(self.symbol) if asset_obj is None: raise exceptions.TokenNotFound(f'Failed to issue because {self.symbol} is an invalid token symbol.') # trim input amount to the token's precision just to be safe str_amount = ('{0:.' + str(asset_obj['precision']) + 'f}').format(amount) amount = Decimal(str_amount) if not self.is_amount_above_minimum(amount, asset_obj['precision']): raise ArithmeticError(f'Failed to issue because {amount} is less than the minimum amount allowed for {self.symbol} tokens.') to_account = self.get_account_obj(address) if to_account is None: raise exceptions.AccountNotFound(f'Failed to issue because issuing account {address} could not be found.') amount_obj = Amount(str_amount, self.symbol, blockchain_instance=self.bitshares) try: # make sure we have the necessary private keys loaded (memo key for encrypting memo, active key for issuing coins) self.set_wallet_keys(address, [ 'memo', 'active' ]) if memo is None: memo = '' memo_obj = Memo(from_account=to_account, to_account=to_account, blockchain_instance=self.bitshares) encrypted_memo = memo_obj.encrypt(memo) # construct the transaction - note that transaction fee for issuance will be paid in BTS, but we retain the # flexibility to add support for paying the fee in the issuing token if deemed necessary op = operations.Asset_issue( **{ "fee": {"amount": 0, "asset_id": "1.3.0"}, "issuer": to_account["id"], "asset_to_issue": {"amount": int(amount_obj), "asset_id": amount_obj.asset["id"]}, "memo": encrypted_memo, "issue_to_account": to_account["id"], "extensions": [], "prefix": self.bitshares.prefix, } ) log.debug('doing token issuance - address[%s], amount[%s %s], memo[%s]', address, str_amount, self.symbol, memo) # broadcast the transaction self.bitshares.finalizeOp(op, to_account, "active") result = self.bitshares.broadcast() except KeyNotFound as e: raise exceptions.IssuerKeyError(str(e)) except exceptions.AuthorityMissing as e: raise exceptions.IssuerKeyError(str(e)) return { 'txid': None, # transaction ID is not readily available from the Bitshares API 'coin': self.orig_symbol, 'amount': self.get_decimal_from_amount(amount_obj), 'fee': Decimal(0), # fee is in BTS, not the issuing token 'from': address, 'send_type': 'issue' }