a4-cli 0.29.0

CLI tool for generating TypeScript SDKs from Arete stream specifications
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

"""Vault program package extension (Python)."""

from arete import create_prepared_instruction, instruction_operation

from . import vault_math
from .models import Vault, vault_from_wire
from .programs import VAULT_PROGRAM_ID

TREASURY = "Treasury11111111111111111111111111111111111"


def create_operations(ctx):
    async def deposit(*, mint, amount, authority=None):
        authority = authority or ctx.wallet.public_key
        instruction = ctx.program.raw.deposit.build(
            authority=authority, vault=TREASURY, mint=mint, amount=amount
        )
        return create_prepared_instruction(
            name="treasury.deposit",
            instruction=instruction,
            artifacts={"authority": authority},
        )

    return {"instructions": {"treasury": {"deposit": instruction_operation(deposit)}}}


def vault_balance(payload) -> int:
    """The raw balance of a wire `Vault` account payload."""
    vault: Vault = vault_from_wire(payload)
    return vault.balance


def create_read(ctx):
    async def slot():
        return (await ctx.chain.clock()).slot

    async def vault(address):
        return await ctx.program.accounts.vault.fetch(address)

    async def balance(address):
        account = await vault(address)
        return None if account is None else account.balance

    return {"slot": slot, "vault": vault, "balance": balance}


PROGRAM_EXTENSIONS = {
    "addresses": {"treasury": lambda: TREASURY, "program": lambda: VAULT_PROGRAM_ID},
    "constants": {"treasury": TREASURY, "vault_decimals": vault_math.VAULT_DECIMALS},
    "math": {"to_raw": vault_math.to_raw, "vault_balance": vault_balance},
    "create_operations": create_operations,
    "create_read": create_read,
}