Mint and Burn Integration

use std::time::{SystemTime, UNIX_EPOCH};
use rgb_lib::Assignment;

let expiration_timestamp = SystemTime::now()
    .duration_since(UNIX_EPOCH)?
    .as_secs()
    + 86_400;
let receive = wallet.blind_receive(
    None,            // the asset ID is omitted from the invoice
    Assignment::Any, // the bridge binds the prepared mint amount
    expiration_timestamp,
    vec!["rpcs://rgb-proxy.utexo.com/json-rpc".to_owned()],
    1,               // confirmations required before the receive settles
)?;

let invoice = receive.invoice;
let receive_transfer_index = receive.batch_transfer_idx;

curl -X POST https://transfer.gateway.stage.utexo.com/api/v0/mint/op-id \
  -H "X-API-Key: <OPERATOR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "networkId": 827166,
    "sourceNetworkId": 42161,
    "tokenId": 2,
    "assetId": "<RGB_ASSET_ID>",
    "invoice": "rgb:...",
    "amount": 1000000
  }'

{
  "opId": "9f2c...e41a",
  "ttlSeconds": 600,
  "settlementData": "0x9f2c...e41a",
  "depositAmount": "1000000",
  "mintAmount": "989500"
}

import { createWalletClient, http, parseAbi } from "viem";
import { arbitrum } from "viem/chains";

const bridgeAbi = parseAbi([
  "function fundsIn(uint256 amount, uint256 destinationChainId, string destinationAddress, bytes settlementData) payable returns (bytes32 operationId)",
]);
const erc20Abi = parseAbi([
  "function approve(address spender, uint256 amount) returns (bool)",
]);

// wallet: a viem wallet client for your EVM account on Arbitrum
await wallet.writeContract({
  address: sourceToken,
  abi: erc20Abi,
  functionName: "approve",
  args: [bridgeContract, BigInt(depositAmount)],
});

await wallet.writeContract({
  address: bridgeContract,
  abi: bridgeAbi,
  functionName: "fundsIn",
  args: [BigInt(depositAmount), 827166n, "", settlementData],
});

curl https://transfer.gateway.stage.utexo.com/api/v0/lock/9f2c...e41a/status \
  -H "X-API-Key: <OPERATOR_API_KEY>"

wallet.refresh(online, None, vec![], false)?;
let balance = wallet.get_asset_balance(rgb_asset_id.to_owned())?;

println!(
    "settled={}, future={}, spendable={}",
    balance.settled,
    balance.future,
    balance.spendable,
);

curl https://transfer.gateway.stage.utexo.com/api/v0/mint-burn/estimate/827166/42161/2/1000000

curl https://transfer.gateway.stage.utexo.com/api/v0/unlock/capacity/827166/42161/<EVM_TOKEN_ID>

{
  "srcNetworkId": 827166,
  "networkId": 42161,
  "tokenId": 2,
  "poolBalance": "1354199",
  "pendingReleases": "0",
  "availableOutflow": "135419",
  "available": "135419"
}

wallet.refresh(online, None, vec![], false)?;

let balance = wallet.get_asset_balance(rgb_asset_id.to_owned())?;
if balance.spendable < burn_amount {
    return Err("the BFA balance is not yet spendable".into());
}

let unspents = wallet.list_unspents(Some(online), false, false)?;
let has_empty_colorable_utxo = unspents.iter().any(|unspent| {
    unspent.utxo.colorable
        && unspent.utxo.exists
        && unspent.utxo.btc_amount >= 1000
        && unspent.rgb_allocations.is_empty()
        && unspent.pending_blinded == 0
});

if !has_empty_colorable_utxo {
    wallet.create_utxos(online, true, Some(5), Some(1000), fee_rate, false)?;
}

EVM address:    f39fd6e51aad88f6f4ce6ab8827279cfffb92266
Burn recipient: 000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266

let evm_address = hex::decode(
    "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266".trim_start_matches("0x"),
)?;
if evm_address.len() != 20 {
    return Err("the EVM recipient must be exactly 20 bytes".into());
}

let mut burn_recipient = vec![0u8; 32];
burn_recipient[12..].copy_from_slice(&evm_address);

let burn = wallet.burn(
    online,
    rgb_asset_id.to_owned(),
    1_000_000,
    Some(burn_recipient),
    5, // fee rate in sat/vB
    1, // confirmations required by the wallet
)?;

let burn_txid = burn.txid;
let burn_transfer_index = burn.batch_transfer_idx;

use base64::{Engine as _, engine::general_purpose::STANDARD};

let consignment_path = wallet.get_send_consignment_path(
    &rgb_asset_id,
    &burn_txid,
);
let consignment = std::fs::read(consignment_path)?;
let base64_consignment = STANDARD.encode(consignment);

curl -X POST https://transfer.gateway.stage.utexo.com/api/v0/unlock \
  -H "X-API-Key: <OPERATOR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "consignment": "<BASE64_CONSIGNMENT>",
    "srcNetworkId": 827166,
    "destinationNetworkId": 42161,
    "tokenId": 2,
    "maxFeeRate": "1000000000"
  }'

{
  "evmTxHash": "0xabc...",
  "status": "submitted",
  "recipient": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266"
}