xrpl-dev-portal/_code-samples/vaults/py/vault_setup.py

import json
import sys
from xrpl.clients import JsonRpcClient
from xrpl.wallet import generate_faucet_wallet
from xrpl.transaction import submit_and_wait
from xrpl.models import (
    MPTokenIssuanceCreate, MPTokenIssuanceCreateFlag,
    PermissionedDomainSet, CredentialCreate, CredentialAccept,
    MPTokenAuthorize, Payment, VaultDeposit,
    Batch, BatchFlag
)
from xrpl.models.transactions.vault_create import (
    VaultCreate, VaultCreateFlag, WithdrawalPolicy
)
from xrpl.models.transactions.deposit_preauth import Credential
from xrpl.utils import str_to_hex, encode_mptoken_metadata

# Setup script for vault tutorials
print("Setting up tutorial: 0/7", end="\r")

client = JsonRpcClient("https://s.devnet.rippletest.net:51234")

# Create and fund all wallets
mpt_issuer = generate_faucet_wallet(client)
domain_owner = generate_faucet_wallet(client)
depositor = generate_faucet_wallet(client)
vault_owner = generate_faucet_wallet(client)

# Step 1: Create MPT issuance
print("Setting up tutorial: 1/7", end="\r")

mpt_create_result = submit_and_wait(
    MPTokenIssuanceCreate(
        account=mpt_issuer.address,
        flags=(
            MPTokenIssuanceCreateFlag.TF_MPT_CAN_TRANSFER |
            MPTokenIssuanceCreateFlag.TF_MPT_CAN_LOCK
        ),
        asset_scale=2,
        transfer_fee=0,
        maximum_amount="1000000000000",
        mptoken_metadata=encode_mptoken_metadata({
            "ticker": "USTST",
            "name": "USTST Stablecoin",
            "desc": "A test stablecoin token",
            "icon": "example.org/ustst-icon.png",
            "asset_class": "rwa",
            "asset_subclass": "stablecoin",
            "issuer_name": "Test Stablecoin Inc",
            "uris": [
                {
                    "uri": "example.org/ustst",
                    "category": "website",
                    "title": "USTST Official Website",
                },
                {
                    "uri": "example.org/ustst/reserves",
                    "category": "attestation",
                    "title": "Reserve Attestation Reports",
                },
                {
                    "uri": "example.org/ustst/docs",
                    "category": "docs",
                    "title": "USTST Documentation",
                },
            ],
            "additional_info": {
                "backing": "USD",
                "reserve_ratio": "1:1",
            },
        }),
    ),
    client,
    mpt_issuer,
    autofill=True
)

mpt_issuance_id = mpt_create_result.result["meta"]["mpt_issuance_id"]

# Step 2: Create Permissioned Domain
print("Setting up tutorial: 2/7", end="\r")

cred_type = "VaultAccess"
domain_result = submit_and_wait(
    PermissionedDomainSet(
        account=domain_owner.address,
        accepted_credentials=[
            Credential(
                issuer=domain_owner.address,
                credential_type=str_to_hex(cred_type)
            )
        ],
    ),
    client,
    domain_owner,
    autofill=True
)

domain_node = next(
    node for node in domain_result.result["meta"]["AffectedNodes"]
    if "CreatedNode" in node and node["CreatedNode"].get("LedgerEntryType") == "PermissionedDomain"
)
domain_id = domain_node["CreatedNode"]["LedgerIndex"]

# Step 3: Create depositor account with credentials and MPT balance
print("Setting up tutorial: 3/7", end="\r")

# Create credential for depositor
submit_and_wait(
    CredentialCreate(
        account=domain_owner.address,
        subject=depositor.address,
        credential_type=str_to_hex(cred_type),
    ),
    client,
    domain_owner,
    autofill=True
)

# Depositor accepts credential and authorizes MPT in a batch transaction
submit_and_wait(
    Batch(
        account=depositor.address,
        flags=BatchFlag.TF_ALL_OR_NOTHING,
        raw_transactions=[
            CredentialAccept(
                account=depositor.address,
                issuer=domain_owner.address,
                credential_type=str_to_hex(cred_type),
            ),
            MPTokenAuthorize(
                account=depositor.address,
                mptoken_issuance_id=mpt_issuance_id,
            ),
        ],
    ),
    client,
    depositor,
    autofill=True
)

print("Setting up tutorial: 4/7", end="\r")

payment_result = submit_and_wait(
    Payment(
        account=mpt_issuer.address,
        destination=depositor.address,
        amount={
            "mpt_issuance_id": mpt_issuance_id,
            "value": "10000",
        },
    ),
    client,
    mpt_issuer,
    autofill=True
)

if payment_result.result["meta"]["TransactionResult"] != "tesSUCCESS":
    print(f"\nPayment failed: {payment_result.result['meta']['TransactionResult']}", file=sys.stderr)
    sys.exit(1)

# Step 5: Create a vault for deposit/withdraw examples
print("Setting up tutorial: 5/7", end="\r")

vault_create_result = submit_and_wait(
    VaultCreate(
        account=vault_owner.address,
        asset={"mpt_issuance_id": mpt_issuance_id},
        flags=VaultCreateFlag.TF_VAULT_PRIVATE,
        domain_id=domain_id,
        data=str_to_hex(json.dumps(
            {"n": "LATAM Fund II", "w": "examplefund.com"}
        )),
        mptoken_metadata=encode_mptoken_metadata({
            "ticker": "SHARE1",
            "name": "Vault Shares",
            "desc": "Proportional ownership shares of the vault",
            "icon": "example.com/vault-shares-icon.png",
            "asset_class": "defi",
            "issuer_name": "Vault Owner",
            "uris": [
                {
                    "uri": "example.com/asset",
                    "category": "website",
                    "title": "Asset Website",
                },
                {
                    "uri": "example.com/docs",
                    "category": "docs",
                    "title": "Docs",
                },
            ],
            "additional_info": {
                "example_info": "test",
            },
        }),
        assets_maximum="0",
        withdrawal_policy=WithdrawalPolicy.VAULT_STRATEGY_FIRST_COME_FIRST_SERVE,
    ),
    client,
    vault_owner,
    autofill=True
)

vault_node = next(
    node for node in vault_create_result.result["meta"]["AffectedNodes"]
    if "CreatedNode" in node and node["CreatedNode"].get("LedgerEntryType") == "Vault"
)
vault_id = vault_node["CreatedNode"]["LedgerIndex"]
vault_share_mpt_issuance_id = vault_node["CreatedNode"]["NewFields"]["ShareMPTID"]

# Step 6: Make an initial deposit so withdraw example has shares to work with
print("Setting up tutorial: 6/7", end="\r")

initial_deposit_result = submit_and_wait(
    VaultDeposit(
        account=depositor.address,
        vault_id=vault_id,
        amount={
            "mpt_issuance_id": mpt_issuance_id,
            "value": "1000",
        },
    ),
    client,
    depositor,
    autofill=True
)

if initial_deposit_result.result["meta"]["TransactionResult"] != "tesSUCCESS":
    print(f"\nInitial deposit failed: {initial_deposit_result.result['meta']['TransactionResult']}", file=sys.stderr)
    sys.exit(1)

# Step 7: Save setup data to file
print("Setting up tutorial: 7/7", end="\r")

setup_data = {
    "mptIssuer": {
        "address": mpt_issuer.address,
        "seed": mpt_issuer.seed,
    },
    "mptIssuanceId": mpt_issuance_id,
    "domainOwner": {
        "address": domain_owner.address,
        "seed": domain_owner.seed,
    },
    "domainId": domain_id,
    "credentialType": cred_type,
    "depositor": {
        "address": depositor.address,
        "seed": depositor.seed,
    },
    "vaultOwner": {
        "address": vault_owner.address,
        "seed": vault_owner.seed,
    },
    "vaultID": vault_id,
    "vaultShareMPTIssuanceId": vault_share_mpt_issuance_id,
}

with open("vault_setup.json", "w") as f:
    json.dump(setup_data, f, indent=2)

print("Setting up tutorial: Complete!")