Issue an asset

/**
 * Issue an asset: a mintable, freezable token with ARRK-AMS-1 metadata; pay, mint, freeze.
 *
 *   ARREKTA_URL=http://127.0.0.1:28332 ARREKTA_ADMIN_TOKEN=... npx tsx examples/issue-asset.ts
 */
import {
  createClient,
  formatUnits,
  freezeAsset,
  fromHex,
  generateSeed,
  getAsset,
  getChain,
  getCoins,
  getFrozen,
  issueAsset,
  keychainFromSeed,
  mine,
  mintAsset,
  sendPayment,
  unfreezeAsset,
} from 'arrekta-sdk';
 
const URL = process.env.ARREKTA_URL ?? 'http://127.0.0.1:28332';
const ADMIN = process.env.ARREKTA_ADMIN_TOKEN;
const SEED = fromHex(process.env.ARREKTA_SEED ?? 'a1'.repeat(32));
 
// 1. Connect; the issuer's wallet and a holder's.
const client = createClient({ url: URL, adminToken: ADMIN });
const { network } = await getChain(client);
const issuer = keychainFromSeed(SEED, { network });
const holder = keychainFromSeed(generateSeed(), { network });
if ((await getCoins(client, { wallet: issuer })).length === 0) await mine(client, issuer.address(0), 101);
 
// 2. Issue 1,000.00 units (max 5,000.00), mintable and freezable, with metadata.
const letters = 'ABCDEFGHJKLMNPQRSTUVWXYZ';
const ticker = 'GLD' + Array.from({ length: 4 }, () => letters[Math.floor(Math.random() * letters.length)]).join('');
const metadata = {
  schema: 'arrk-ams-1',
  ticker,
  name: 'Demo Gold',
  issuer: { name: 'Demo Issuer' },
  controls_policy: 'Freezes only on court order.',
};
const issued = await issueAsset(client, {
  wallet: issuer,
  ticker,
  name: 'Demo Gold',
  amount: '1000',
  decimals: 2,
  maxSupply: '5000',
  mintable: true,
  freezable: true,
  metadata,
});
await mine(client, issuer.address(0), 1);
console.log(`issued ${ticker} = ${issued.asset}`);
 
// 3. Pay the holder 12.50 units.
await sendPayment(client, { wallet: issuer, to: holder.address(0), amount: '12.5', asset: ticker });
await mine(client, issuer.address(0), 1);
 
// 4. Mint 100.00 more (spends and re-creates the authority token).
await mintAsset(client, { wallet: issuer, asset: ticker, amount: '100' });
await mine(client, issuer.address(0), 1);
const asset = await getAsset(client, { idOrTicker: ticker });
console.log(`supply ${formatUnits(asset.issued, asset.decimals)} ${ticker}`);
 
// 5. Freeze the holder, list frozen holders, then unfreeze.
await freezeAsset(client, { wallet: issuer, asset: ticker, address: holder.address(0) });
await mine(client, issuer.address(0), 1);
console.log('frozen:', (await getFrozen(client, { asset: ticker })).frozen.map((f) => f.address));
await unfreezeAsset(client, { wallet: issuer, asset: ticker, address: holder.address(0) });
await mine(client, issuer.address(0), 1);
console.log('frozen after unfreeze:', (await getFrozen(client, { asset: ticker })).frozen);

"""Issue an asset: a mintable, freezable token with ARRK-AMS-1 metadata; pay, mint, freeze.
 
    ARREKTA_URL=http://127.0.0.1:28332 ARREKTA_ADMIN_TOKEN=... python examples/issue_asset.py
"""
 
import os
import secrets
 
from arrekta_sdk import Client, format_units, generate_seed, keychain_from_seed
 
URL = os.environ.get("ARREKTA_URL", "http://127.0.0.1:28332")
ADMIN = os.environ.get("ARREKTA_ADMIN_TOKEN")
SEED = bytes.fromhex(os.environ.get("ARREKTA_SEED", "a1" * 32))
 
 
def main() -> None:
    # 1. Connect; the issuer's wallet and a holder's.
    client = Client(URL, admin_token=ADMIN)
    network = client.get_chain()["network"]
    issuer = keychain_from_seed(SEED, network=network)
    holder = keychain_from_seed(generate_seed(), network=network)
    if not client.get_coins(issuer):
        client.mine(issuer.address(0), 101)
 
    # 2. Issue 1,000.00 units (max 5,000.00), mintable and freezable, with metadata.
    ticker = "GLD" + "".join(secrets.choice("ABCDEFGHJKLMNPQRSTUVWXYZ") for _ in range(4))
    metadata = {"schema": "arrk-ams-1", "ticker": ticker, "name": "Demo Gold",
                "issuer": {"name": "Demo Issuer"}, "controls_policy": "Freezes only on court order."}
    issued = client.issue_asset(issuer, ticker, "Demo Gold", "1000", decimals=2, max_supply="5000",
                                mintable=True, freezable=True, metadata=metadata)
    client.mine(issuer.address(0), 1)
    print(f"issued {ticker} = {issued.asset}")
 
    # 3. Pay the holder 12.50 units.
    client.send_payment(issuer, holder.address(0), "12.5", asset=ticker)
    client.mine(issuer.address(0), 1)
 
    # 4. Mint 100.00 more (spends and re-creates the authority token).
    client.mint_asset(issuer, ticker, "100")
    client.mine(issuer.address(0), 1)
    asset = client.get_asset(ticker)
    print(f"supply {format_units(asset['issued'], asset['decimals'])} {ticker}")
 
    # 5. Freeze the holder, list frozen holders, then unfreeze.
    client.freeze_asset(issuer, ticker, holder.address(0))
    client.mine(issuer.address(0), 1)
    print("frozen:", [f["address"] for f in client.get_frozen(ticker)["frozen"]])
    client.unfreeze_asset(issuer, ticker, holder.address(0))
    client.mine(issuer.address(0), 1)
    print("frozen after unfreeze:", client.get_frozen(ticker)["frozen"])
 
 
if __name__ == "__main__":
    main()