>,
+ second_state: Account<'info, State2>,
+ system_program: Program<'info, System>,
+}
+
+#[derive(Accounts)]
+pub struct CauseError {}
+
+#[error_code]
+pub enum ErrorCode {
+ #[msg("Example error.")]
+ SomeError,
+ #[msg("Another error.")]
+ OtherError,
+}
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/__init__.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/__init__.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/__init__.py
new file mode 100644
index 0000000..69f5a39
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/__init__.py
@@ -0,0 +1,4 @@
+from .my_account import MyAccount, MyAccountJSON
+from .base_account import BaseAccount, BaseAccountJSON
+from .state import State, StateJSON
+from .state2 import State2, State2JSON
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/base_account.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/base_account.py
new file mode 100644
index 0000000..b3978ca
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/base_account.py
@@ -0,0 +1,87 @@
+import typing
+from dataclasses import dataclass
+from solders.pubkey import Pubkey
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Commitment
+import borsh_construct as borsh
+from anchorpy.coder.accounts import ACCOUNT_DISCRIMINATOR_SIZE
+from anchorpy.error import AccountInvalidDiscriminator
+from anchorpy.utils.rpc import get_multiple_accounts
+from anchorpy.borsh_extension import BorshPubkey
+from ..program_id import PROGRAM_ID
+
+
+class BaseAccountJSON(typing.TypedDict):
+ base_data: int
+ base_data_key: str
+
+
+@dataclass
+class BaseAccount:
+ discriminator: typing.ClassVar = b"\x10Z\x82\xf2\x9f\n\xe8\x85"
+ layout: typing.ClassVar = borsh.CStruct(
+ "base_data" / borsh.U64, "base_data_key" / BorshPubkey
+ )
+ base_data: int
+ base_data_key: Pubkey
+
+ @classmethod
+ async def fetch(
+ cls,
+ conn: AsyncClient,
+ address: Pubkey,
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.Optional["BaseAccount"]:
+ resp = await conn.get_account_info(address, commitment=commitment)
+ info = resp.value
+ if info is None:
+ return None
+ if info.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ bytes_data = info.data
+ return cls.decode(bytes_data)
+
+ @classmethod
+ async def fetch_multiple(
+ cls,
+ conn: AsyncClient,
+ addresses: list[Pubkey],
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.List[typing.Optional["BaseAccount"]]:
+ infos = await get_multiple_accounts(conn, addresses, commitment=commitment)
+ res: typing.List[typing.Optional["BaseAccount"]] = []
+ for info in infos:
+ if info is None:
+ res.append(None)
+ continue
+ if info.account.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ res.append(cls.decode(info.account.data))
+ return res
+
+ @classmethod
+ def decode(cls, data: bytes) -> "BaseAccount":
+ if data[:ACCOUNT_DISCRIMINATOR_SIZE] != cls.discriminator:
+ raise AccountInvalidDiscriminator(
+ "The discriminator for this account is invalid"
+ )
+ dec = BaseAccount.layout.parse(data[ACCOUNT_DISCRIMINATOR_SIZE:])
+ return cls(
+ base_data=dec.base_data,
+ base_data_key=dec.base_data_key,
+ )
+
+ def to_json(self) -> BaseAccountJSON:
+ return {
+ "base_data": self.base_data,
+ "base_data_key": str(self.base_data_key),
+ }
+
+ @classmethod
+ def from_json(cls, obj: BaseAccountJSON) -> "BaseAccount":
+ return cls(
+ base_data=obj["base_data"],
+ base_data_key=Pubkey.from_string(obj["base_data_key"]),
+ )
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/my_account.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/my_account.py
new file mode 100644
index 0000000..49c922b
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/my_account.py
@@ -0,0 +1,79 @@
+import typing
+from dataclasses import dataclass
+from solders.pubkey import Pubkey
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Commitment
+import borsh_construct as borsh
+from anchorpy.coder.accounts import ACCOUNT_DISCRIMINATOR_SIZE
+from anchorpy.error import AccountInvalidDiscriminator
+from anchorpy.utils.rpc import get_multiple_accounts
+from ..program_id import PROGRAM_ID
+
+
+class MyAccountJSON(typing.TypedDict):
+ data: int
+
+
+@dataclass
+class MyAccount:
+ discriminator: typing.ClassVar = b"\xf6\x1c\x06W\xfb-2*"
+ layout: typing.ClassVar = borsh.CStruct("data" / borsh.U64)
+ data: int
+
+ @classmethod
+ async def fetch(
+ cls,
+ conn: AsyncClient,
+ address: Pubkey,
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.Optional["MyAccount"]:
+ resp = await conn.get_account_info(address, commitment=commitment)
+ info = resp.value
+ if info is None:
+ return None
+ if info.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ bytes_data = info.data
+ return cls.decode(bytes_data)
+
+ @classmethod
+ async def fetch_multiple(
+ cls,
+ conn: AsyncClient,
+ addresses: list[Pubkey],
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.List[typing.Optional["MyAccount"]]:
+ infos = await get_multiple_accounts(conn, addresses, commitment=commitment)
+ res: typing.List[typing.Optional["MyAccount"]] = []
+ for info in infos:
+ if info is None:
+ res.append(None)
+ continue
+ if info.account.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ res.append(cls.decode(info.account.data))
+ return res
+
+ @classmethod
+ def decode(cls, data: bytes) -> "MyAccount":
+ if data[:ACCOUNT_DISCRIMINATOR_SIZE] != cls.discriminator:
+ raise AccountInvalidDiscriminator(
+ "The discriminator for this account is invalid"
+ )
+ dec = MyAccount.layout.parse(data[ACCOUNT_DISCRIMINATOR_SIZE:])
+ return cls(
+ data=dec.data,
+ )
+
+ def to_json(self) -> MyAccountJSON:
+ return {
+ "data": self.data,
+ }
+
+ @classmethod
+ def from_json(cls, obj: MyAccountJSON) -> "MyAccount":
+ return cls(
+ data=obj["data"],
+ )
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/state.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/state.py
new file mode 100644
index 0000000..1c0f39f
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/state.py
@@ -0,0 +1,259 @@
+import typing
+from dataclasses import dataclass
+from construct import Construct
+from solders.pubkey import Pubkey
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Commitment
+import borsh_construct as borsh
+from anchorpy.coder.accounts import ACCOUNT_DISCRIMINATOR_SIZE
+from anchorpy.error import AccountInvalidDiscriminator
+from anchorpy.utils.rpc import get_multiple_accounts
+from anchorpy.borsh_extension import BorshPubkey
+from ..program_id import PROGRAM_ID
+from .. import types
+
+
+class StateJSON(typing.TypedDict):
+ bool_field: bool
+ u8_field: int
+ i8_field: int
+ u16_field: int
+ i16_field: int
+ u32_field: int
+ i32_field: int
+ f32_field: float
+ u64_field: int
+ i64_field: int
+ f64_field: float
+ u128_field: int
+ i128_field: int
+ bytes_field: list[int]
+ string_field: str
+ pubkey_field: str
+ vec_field: list[int]
+ vec_struct_field: list[types.foo_struct.FooStructJSON]
+ option_field: typing.Optional[bool]
+ option_struct_field: typing.Optional[types.foo_struct.FooStructJSON]
+ struct_field: types.foo_struct.FooStructJSON
+ array_field: list[bool]
+ enum_field1: types.foo_enum.FooEnumJSON
+ enum_field2: types.foo_enum.FooEnumJSON
+ enum_field3: types.foo_enum.FooEnumJSON
+ enum_field4: types.foo_enum.FooEnumJSON
+
+
+@dataclass
+class State:
+ discriminator: typing.ClassVar = b"\xd8\x92k^hK\xb6\xb1"
+ layout: typing.ClassVar = borsh.CStruct(
+ "bool_field" / borsh.Bool,
+ "u8_field" / borsh.U8,
+ "i8_field" / borsh.I8,
+ "u16_field" / borsh.U16,
+ "i16_field" / borsh.I16,
+ "u32_field" / borsh.U32,
+ "i32_field" / borsh.I32,
+ "f32_field" / borsh.F32,
+ "u64_field" / borsh.U64,
+ "i64_field" / borsh.I64,
+ "f64_field" / borsh.F64,
+ "u128_field" / borsh.U128,
+ "i128_field" / borsh.I128,
+ "bytes_field" / borsh.Bytes,
+ "string_field" / borsh.String,
+ "pubkey_field" / BorshPubkey,
+ "vec_field" / borsh.Vec(typing.cast(Construct, borsh.U64)),
+ "vec_struct_field"
+ / borsh.Vec(typing.cast(Construct, types.foo_struct.FooStruct.layout)),
+ "option_field" / borsh.Option(borsh.Bool),
+ "option_struct_field" / borsh.Option(types.foo_struct.FooStruct.layout),
+ "struct_field" / types.foo_struct.FooStruct.layout,
+ "array_field" / borsh.Bool[3],
+ "enum_field1" / types.foo_enum.layout,
+ "enum_field2" / types.foo_enum.layout,
+ "enum_field3" / types.foo_enum.layout,
+ "enum_field4" / types.foo_enum.layout,
+ )
+ bool_field: bool
+ u8_field: int
+ i8_field: int
+ u16_field: int
+ i16_field: int
+ u32_field: int
+ i32_field: int
+ f32_field: float
+ u64_field: int
+ i64_field: int
+ f64_field: float
+ u128_field: int
+ i128_field: int
+ bytes_field: bytes
+ string_field: str
+ pubkey_field: Pubkey
+ vec_field: list[int]
+ vec_struct_field: list[types.foo_struct.FooStruct]
+ option_field: typing.Optional[bool]
+ option_struct_field: typing.Optional[types.foo_struct.FooStruct]
+ struct_field: types.foo_struct.FooStruct
+ array_field: list[bool]
+ enum_field1: types.foo_enum.FooEnumKind
+ enum_field2: types.foo_enum.FooEnumKind
+ enum_field3: types.foo_enum.FooEnumKind
+ enum_field4: types.foo_enum.FooEnumKind
+
+ @classmethod
+ async def fetch(
+ cls,
+ conn: AsyncClient,
+ address: Pubkey,
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.Optional["State"]:
+ resp = await conn.get_account_info(address, commitment=commitment)
+ info = resp.value
+ if info is None:
+ return None
+ if info.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ bytes_data = info.data
+ return cls.decode(bytes_data)
+
+ @classmethod
+ async def fetch_multiple(
+ cls,
+ conn: AsyncClient,
+ addresses: list[Pubkey],
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.List[typing.Optional["State"]]:
+ infos = await get_multiple_accounts(conn, addresses, commitment=commitment)
+ res: typing.List[typing.Optional["State"]] = []
+ for info in infos:
+ if info is None:
+ res.append(None)
+ continue
+ if info.account.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ res.append(cls.decode(info.account.data))
+ return res
+
+ @classmethod
+ def decode(cls, data: bytes) -> "State":
+ if data[:ACCOUNT_DISCRIMINATOR_SIZE] != cls.discriminator:
+ raise AccountInvalidDiscriminator(
+ "The discriminator for this account is invalid"
+ )
+ dec = State.layout.parse(data[ACCOUNT_DISCRIMINATOR_SIZE:])
+ return cls(
+ bool_field=dec.bool_field,
+ u8_field=dec.u8_field,
+ i8_field=dec.i8_field,
+ u16_field=dec.u16_field,
+ i16_field=dec.i16_field,
+ u32_field=dec.u32_field,
+ i32_field=dec.i32_field,
+ f32_field=dec.f32_field,
+ u64_field=dec.u64_field,
+ i64_field=dec.i64_field,
+ f64_field=dec.f64_field,
+ u128_field=dec.u128_field,
+ i128_field=dec.i128_field,
+ bytes_field=dec.bytes_field,
+ string_field=dec.string_field,
+ pubkey_field=dec.pubkey_field,
+ vec_field=dec.vec_field,
+ vec_struct_field=list(
+ map(
+ lambda item: types.foo_struct.FooStruct.from_decoded(item),
+ dec.vec_struct_field,
+ )
+ ),
+ option_field=dec.option_field,
+ option_struct_field=(
+ None
+ if dec.option_struct_field is None
+ else types.foo_struct.FooStruct.from_decoded(dec.option_struct_field)
+ ),
+ struct_field=types.foo_struct.FooStruct.from_decoded(dec.struct_field),
+ array_field=dec.array_field,
+ enum_field1=types.foo_enum.from_decoded(dec.enum_field1),
+ enum_field2=types.foo_enum.from_decoded(dec.enum_field2),
+ enum_field3=types.foo_enum.from_decoded(dec.enum_field3),
+ enum_field4=types.foo_enum.from_decoded(dec.enum_field4),
+ )
+
+ def to_json(self) -> StateJSON:
+ return {
+ "bool_field": self.bool_field,
+ "u8_field": self.u8_field,
+ "i8_field": self.i8_field,
+ "u16_field": self.u16_field,
+ "i16_field": self.i16_field,
+ "u32_field": self.u32_field,
+ "i32_field": self.i32_field,
+ "f32_field": self.f32_field,
+ "u64_field": self.u64_field,
+ "i64_field": self.i64_field,
+ "f64_field": self.f64_field,
+ "u128_field": self.u128_field,
+ "i128_field": self.i128_field,
+ "bytes_field": list(self.bytes_field),
+ "string_field": self.string_field,
+ "pubkey_field": str(self.pubkey_field),
+ "vec_field": self.vec_field,
+ "vec_struct_field": list(
+ map(lambda item: item.to_json(), self.vec_struct_field)
+ ),
+ "option_field": self.option_field,
+ "option_struct_field": (
+ None
+ if self.option_struct_field is None
+ else self.option_struct_field.to_json()
+ ),
+ "struct_field": self.struct_field.to_json(),
+ "array_field": self.array_field,
+ "enum_field1": self.enum_field1.to_json(),
+ "enum_field2": self.enum_field2.to_json(),
+ "enum_field3": self.enum_field3.to_json(),
+ "enum_field4": self.enum_field4.to_json(),
+ }
+
+ @classmethod
+ def from_json(cls, obj: StateJSON) -> "State":
+ return cls(
+ bool_field=obj["bool_field"],
+ u8_field=obj["u8_field"],
+ i8_field=obj["i8_field"],
+ u16_field=obj["u16_field"],
+ i16_field=obj["i16_field"],
+ u32_field=obj["u32_field"],
+ i32_field=obj["i32_field"],
+ f32_field=obj["f32_field"],
+ u64_field=obj["u64_field"],
+ i64_field=obj["i64_field"],
+ f64_field=obj["f64_field"],
+ u128_field=obj["u128_field"],
+ i128_field=obj["i128_field"],
+ bytes_field=bytes(obj["bytes_field"]),
+ string_field=obj["string_field"],
+ pubkey_field=Pubkey.from_string(obj["pubkey_field"]),
+ vec_field=obj["vec_field"],
+ vec_struct_field=list(
+ map(
+ lambda item: types.foo_struct.FooStruct.from_json(item),
+ obj["vec_struct_field"],
+ )
+ ),
+ option_field=obj["option_field"],
+ option_struct_field=(
+ None
+ if obj["option_struct_field"] is None
+ else types.foo_struct.FooStruct.from_json(obj["option_struct_field"])
+ ),
+ struct_field=types.foo_struct.FooStruct.from_json(obj["struct_field"]),
+ array_field=obj["array_field"],
+ enum_field1=types.foo_enum.from_json(obj["enum_field1"]),
+ enum_field2=types.foo_enum.from_json(obj["enum_field2"]),
+ enum_field3=types.foo_enum.from_json(obj["enum_field3"]),
+ enum_field4=types.foo_enum.from_json(obj["enum_field4"]),
+ )
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/state2.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/state2.py
new file mode 100644
index 0000000..2dd9ab1
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/accounts/state2.py
@@ -0,0 +1,82 @@
+import typing
+from dataclasses import dataclass
+from construct import Construct
+from solders.pubkey import Pubkey
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Commitment
+import borsh_construct as borsh
+from anchorpy.coder.accounts import ACCOUNT_DISCRIMINATOR_SIZE
+from anchorpy.error import AccountInvalidDiscriminator
+from anchorpy.utils.rpc import get_multiple_accounts
+from ..program_id import PROGRAM_ID
+
+
+class State2JSON(typing.TypedDict):
+ vec_of_option: list[typing.Optional[int]]
+
+
+@dataclass
+class State2:
+ discriminator: typing.ClassVar = b"ja\xff\xa1\xfa\xcd\xb9\xc0"
+ layout: typing.ClassVar = borsh.CStruct(
+ "vec_of_option" / borsh.Vec(typing.cast(Construct, borsh.Option(borsh.U64)))
+ )
+ vec_of_option: list[typing.Optional[int]]
+
+ @classmethod
+ async def fetch(
+ cls,
+ conn: AsyncClient,
+ address: Pubkey,
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.Optional["State2"]:
+ resp = await conn.get_account_info(address, commitment=commitment)
+ info = resp.value
+ if info is None:
+ return None
+ if info.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ bytes_data = info.data
+ return cls.decode(bytes_data)
+
+ @classmethod
+ async def fetch_multiple(
+ cls,
+ conn: AsyncClient,
+ addresses: list[Pubkey],
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.List[typing.Optional["State2"]]:
+ infos = await get_multiple_accounts(conn, addresses, commitment=commitment)
+ res: typing.List[typing.Optional["State2"]] = []
+ for info in infos:
+ if info is None:
+ res.append(None)
+ continue
+ if info.account.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ res.append(cls.decode(info.account.data))
+ return res
+
+ @classmethod
+ def decode(cls, data: bytes) -> "State2":
+ if data[:ACCOUNT_DISCRIMINATOR_SIZE] != cls.discriminator:
+ raise AccountInvalidDiscriminator(
+ "The discriminator for this account is invalid"
+ )
+ dec = State2.layout.parse(data[ACCOUNT_DISCRIMINATOR_SIZE:])
+ return cls(
+ vec_of_option=dec.vec_of_option,
+ )
+
+ def to_json(self) -> State2JSON:
+ return {
+ "vec_of_option": self.vec_of_option,
+ }
+
+ @classmethod
+ def from_json(cls, obj: State2JSON) -> "State2":
+ return cls(
+ vec_of_option=obj["vec_of_option"],
+ )
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/__init__.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/__init__.py
new file mode 100644
index 0000000..421993d
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/__init__.py
@@ -0,0 +1,29 @@
+import typing
+import re
+from solders.transaction_status import (
+ InstructionErrorCustom,
+ TransactionErrorInstructionError,
+)
+from solana.rpc.core import RPCException
+from solders.rpc.errors import SendTransactionPreflightFailureMessage
+from anchorpy.error import extract_code_and_logs
+from ..program_id import PROGRAM_ID
+from . import anchor
+from . import custom
+
+
+def from_code(code: int) -> typing.Union[custom.CustomError, anchor.AnchorError, None]:
+ return custom.from_code(code) if code >= 6000 else anchor.from_code(code)
+
+
+error_re = re.compile(r"Program (\w+) failed: custom program error: (\w+)")
+
+
+def from_tx_error(
+ error: RPCException,
+) -> typing.Union[anchor.AnchorError, custom.CustomError, None]:
+ err_info = error.args[0]
+ extracted = extract_code_and_logs(err_info, PROGRAM_ID)
+ if extracted is None:
+ return None
+ return from_code(extracted[0])
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/anchor.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/anchor.py
new file mode 100644
index 0000000..3f266ef
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/anchor.py
@@ -0,0 +1,590 @@
+import typing
+from anchorpy.error import ProgramError
+
+
+class InstructionMissing(ProgramError):
+ def __init__(self):
+ super().__init__(100, "8 byte instruction identifier not provided")
+
+ code = 100
+ name = "InstructionMissing"
+ msg = "8 byte instruction identifier not provided"
+
+
+class InstructionFallbackNotFound(ProgramError):
+ def __init__(self):
+ super().__init__(101, "Fallback functions are not supported")
+
+ code = 101
+ name = "InstructionFallbackNotFound"
+ msg = "Fallback functions are not supported"
+
+
+class InstructionDidNotDeserialize(ProgramError):
+ def __init__(self):
+ super().__init__(102, "The program could not deserialize the given instruction")
+
+ code = 102
+ name = "InstructionDidNotDeserialize"
+ msg = "The program could not deserialize the given instruction"
+
+
+class InstructionDidNotSerialize(ProgramError):
+ def __init__(self):
+ super().__init__(103, "The program could not serialize the given instruction")
+
+ code = 103
+ name = "InstructionDidNotSerialize"
+ msg = "The program could not serialize the given instruction"
+
+
+class IdlInstructionStub(ProgramError):
+ def __init__(self):
+ super().__init__(1000, "The program was compiled without idl instructions")
+
+ code = 1000
+ name = "IdlInstructionStub"
+ msg = "The program was compiled without idl instructions"
+
+
+class IdlInstructionInvalidProgram(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 1001, "The transaction was given an invalid program for the IDL instruction"
+ )
+
+ code = 1001
+ name = "IdlInstructionInvalidProgram"
+ msg = "The transaction was given an invalid program for the IDL instruction"
+
+
+class ConstraintMut(ProgramError):
+ def __init__(self):
+ super().__init__(2000, "A mut constraint was violated")
+
+ code = 2000
+ name = "ConstraintMut"
+ msg = "A mut constraint was violated"
+
+
+class ConstraintHasOne(ProgramError):
+ def __init__(self):
+ super().__init__(2001, "A has_one constraint was violated")
+
+ code = 2001
+ name = "ConstraintHasOne"
+ msg = "A has_one constraint was violated"
+
+
+class ConstraintSigner(ProgramError):
+ def __init__(self):
+ super().__init__(2002, "A signer constraint was violated")
+
+ code = 2002
+ name = "ConstraintSigner"
+ msg = "A signer constraint was violated"
+
+
+class ConstraintRaw(ProgramError):
+ def __init__(self):
+ super().__init__(2003, "A raw constraint was violated")
+
+ code = 2003
+ name = "ConstraintRaw"
+ msg = "A raw constraint was violated"
+
+
+class ConstraintOwner(ProgramError):
+ def __init__(self):
+ super().__init__(2004, "An owner constraint was violated")
+
+ code = 2004
+ name = "ConstraintOwner"
+ msg = "An owner constraint was violated"
+
+
+class ConstraintRentExempt(ProgramError):
+ def __init__(self):
+ super().__init__(2005, "A rent exempt constraint was violated")
+
+ code = 2005
+ name = "ConstraintRentExempt"
+ msg = "A rent exempt constraint was violated"
+
+
+class ConstraintSeeds(ProgramError):
+ def __init__(self):
+ super().__init__(2006, "A seeds constraint was violated")
+
+ code = 2006
+ name = "ConstraintSeeds"
+ msg = "A seeds constraint was violated"
+
+
+class ConstraintExecutable(ProgramError):
+ def __init__(self):
+ super().__init__(2007, "An executable constraint was violated")
+
+ code = 2007
+ name = "ConstraintExecutable"
+ msg = "An executable constraint was violated"
+
+
+class ConstraintState(ProgramError):
+ def __init__(self):
+ super().__init__(2008, "A state constraint was violated")
+
+ code = 2008
+ name = "ConstraintState"
+ msg = "A state constraint was violated"
+
+
+class ConstraintAssociated(ProgramError):
+ def __init__(self):
+ super().__init__(2009, "An associated constraint was violated")
+
+ code = 2009
+ name = "ConstraintAssociated"
+ msg = "An associated constraint was violated"
+
+
+class ConstraintAssociatedInit(ProgramError):
+ def __init__(self):
+ super().__init__(2010, "An associated init constraint was violated")
+
+ code = 2010
+ name = "ConstraintAssociatedInit"
+ msg = "An associated init constraint was violated"
+
+
+class ConstraintClose(ProgramError):
+ def __init__(self):
+ super().__init__(2011, "A close constraint was violated")
+
+ code = 2011
+ name = "ConstraintClose"
+ msg = "A close constraint was violated"
+
+
+class ConstraintAddress(ProgramError):
+ def __init__(self):
+ super().__init__(2012, "An address constraint was violated")
+
+ code = 2012
+ name = "ConstraintAddress"
+ msg = "An address constraint was violated"
+
+
+class ConstraintZero(ProgramError):
+ def __init__(self):
+ super().__init__(2013, "Expected zero account discriminant")
+
+ code = 2013
+ name = "ConstraintZero"
+ msg = "Expected zero account discriminant"
+
+
+class ConstraintTokenMint(ProgramError):
+ def __init__(self):
+ super().__init__(2014, "A token mint constraint was violated")
+
+ code = 2014
+ name = "ConstraintTokenMint"
+ msg = "A token mint constraint was violated"
+
+
+class ConstraintTokenOwner(ProgramError):
+ def __init__(self):
+ super().__init__(2015, "A token owner constraint was violated")
+
+ code = 2015
+ name = "ConstraintTokenOwner"
+ msg = "A token owner constraint was violated"
+
+
+class ConstraintMintMintAuthority(ProgramError):
+ def __init__(self):
+ super().__init__(2016, "A mint mint authority constraint was violated")
+
+ code = 2016
+ name = "ConstraintMintMintAuthority"
+ msg = "A mint mint authority constraint was violated"
+
+
+class ConstraintMintFreezeAuthority(ProgramError):
+ def __init__(self):
+ super().__init__(2017, "A mint freeze authority constraint was violated")
+
+ code = 2017
+ name = "ConstraintMintFreezeAuthority"
+ msg = "A mint freeze authority constraint was violated"
+
+
+class ConstraintMintDecimals(ProgramError):
+ def __init__(self):
+ super().__init__(2018, "A mint decimals constraint was violated")
+
+ code = 2018
+ name = "ConstraintMintDecimals"
+ msg = "A mint decimals constraint was violated"
+
+
+class ConstraintSpace(ProgramError):
+ def __init__(self):
+ super().__init__(2019, "A space constraint was violated")
+
+ code = 2019
+ name = "ConstraintSpace"
+ msg = "A space constraint was violated"
+
+
+class RequireViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2500, "A require expression was violated")
+
+ code = 2500
+ name = "RequireViolated"
+ msg = "A require expression was violated"
+
+
+class RequireEqViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2501, "A require_eq expression was violated")
+
+ code = 2501
+ name = "RequireEqViolated"
+ msg = "A require_eq expression was violated"
+
+
+class RequireKeysEqViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2502, "A require_keys_eq expression was violated")
+
+ code = 2502
+ name = "RequireKeysEqViolated"
+ msg = "A require_keys_eq expression was violated"
+
+
+class RequireNeqViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2503, "A require_neq expression was violated")
+
+ code = 2503
+ name = "RequireNeqViolated"
+ msg = "A require_neq expression was violated"
+
+
+class RequireKeysNeqViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2504, "A require_keys_neq expression was violated")
+
+ code = 2504
+ name = "RequireKeysNeqViolated"
+ msg = "A require_keys_neq expression was violated"
+
+
+class RequireGtViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2505, "A require_gt expression was violated")
+
+ code = 2505
+ name = "RequireGtViolated"
+ msg = "A require_gt expression was violated"
+
+
+class RequireGteViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2506, "A require_gte expression was violated")
+
+ code = 2506
+ name = "RequireGteViolated"
+ msg = "A require_gte expression was violated"
+
+
+class AccountDiscriminatorAlreadySet(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 3000, "The account discriminator was already set on this account"
+ )
+
+ code = 3000
+ name = "AccountDiscriminatorAlreadySet"
+ msg = "The account discriminator was already set on this account"
+
+
+class AccountDiscriminatorNotFound(ProgramError):
+ def __init__(self):
+ super().__init__(3001, "No 8 byte discriminator was found on the account")
+
+ code = 3001
+ name = "AccountDiscriminatorNotFound"
+ msg = "No 8 byte discriminator was found on the account"
+
+
+class AccountDiscriminatorMismatch(ProgramError):
+ def __init__(self):
+ super().__init__(3002, "8 byte discriminator did not match what was expected")
+
+ code = 3002
+ name = "AccountDiscriminatorMismatch"
+ msg = "8 byte discriminator did not match what was expected"
+
+
+class AccountDidNotDeserialize(ProgramError):
+ def __init__(self):
+ super().__init__(3003, "Failed to deserialize the account")
+
+ code = 3003
+ name = "AccountDidNotDeserialize"
+ msg = "Failed to deserialize the account"
+
+
+class AccountDidNotSerialize(ProgramError):
+ def __init__(self):
+ super().__init__(3004, "Failed to serialize the account")
+
+ code = 3004
+ name = "AccountDidNotSerialize"
+ msg = "Failed to serialize the account"
+
+
+class AccountNotEnoughKeys(ProgramError):
+ def __init__(self):
+ super().__init__(3005, "Not enough account keys given to the instruction")
+
+ code = 3005
+ name = "AccountNotEnoughKeys"
+ msg = "Not enough account keys given to the instruction"
+
+
+class AccountNotMutable(ProgramError):
+ def __init__(self):
+ super().__init__(3006, "The given account is not mutable")
+
+ code = 3006
+ name = "AccountNotMutable"
+ msg = "The given account is not mutable"
+
+
+class AccountOwnedByWrongProgram(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 3007, "The given account is owned by a different program than expected"
+ )
+
+ code = 3007
+ name = "AccountOwnedByWrongProgram"
+ msg = "The given account is owned by a different program than expected"
+
+
+class InvalidProgramId(ProgramError):
+ def __init__(self):
+ super().__init__(3008, "Program ID was not as expected")
+
+ code = 3008
+ name = "InvalidProgramId"
+ msg = "Program ID was not as expected"
+
+
+class InvalidProgramExecutable(ProgramError):
+ def __init__(self):
+ super().__init__(3009, "Program account is not executable")
+
+ code = 3009
+ name = "InvalidProgramExecutable"
+ msg = "Program account is not executable"
+
+
+class AccountNotSigner(ProgramError):
+ def __init__(self):
+ super().__init__(3010, "The given account did not sign")
+
+ code = 3010
+ name = "AccountNotSigner"
+ msg = "The given account did not sign"
+
+
+class AccountNotSystemOwned(ProgramError):
+ def __init__(self):
+ super().__init__(3011, "The given account is not owned by the system program")
+
+ code = 3011
+ name = "AccountNotSystemOwned"
+ msg = "The given account is not owned by the system program"
+
+
+class AccountNotInitialized(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 3012, "The program expected this account to be already initialized"
+ )
+
+ code = 3012
+ name = "AccountNotInitialized"
+ msg = "The program expected this account to be already initialized"
+
+
+class AccountNotProgramData(ProgramError):
+ def __init__(self):
+ super().__init__(3013, "The given account is not a program data account")
+
+ code = 3013
+ name = "AccountNotProgramData"
+ msg = "The given account is not a program data account"
+
+
+class AccountNotAssociatedTokenAccount(ProgramError):
+ def __init__(self):
+ super().__init__(3014, "The given account is not the associated token account")
+
+ code = 3014
+ name = "AccountNotAssociatedTokenAccount"
+ msg = "The given account is not the associated token account"
+
+
+class AccountSysvarMismatch(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 3015, "The given public key does not match the required sysvar"
+ )
+
+ code = 3015
+ name = "AccountSysvarMismatch"
+ msg = "The given public key does not match the required sysvar"
+
+
+class StateInvalidAddress(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 4000, "The given state account does not have the correct address"
+ )
+
+ code = 4000
+ name = "StateInvalidAddress"
+ msg = "The given state account does not have the correct address"
+
+
+class Deprecated(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 5000, "The API being used is deprecated and should no longer be used"
+ )
+
+ code = 5000
+ name = "Deprecated"
+ msg = "The API being used is deprecated and should no longer be used"
+
+
+AnchorError = typing.Union[
+ InstructionMissing,
+ InstructionFallbackNotFound,
+ InstructionDidNotDeserialize,
+ InstructionDidNotSerialize,
+ IdlInstructionStub,
+ IdlInstructionInvalidProgram,
+ ConstraintMut,
+ ConstraintHasOne,
+ ConstraintSigner,
+ ConstraintRaw,
+ ConstraintOwner,
+ ConstraintRentExempt,
+ ConstraintSeeds,
+ ConstraintExecutable,
+ ConstraintState,
+ ConstraintAssociated,
+ ConstraintAssociatedInit,
+ ConstraintClose,
+ ConstraintAddress,
+ ConstraintZero,
+ ConstraintTokenMint,
+ ConstraintTokenOwner,
+ ConstraintMintMintAuthority,
+ ConstraintMintFreezeAuthority,
+ ConstraintMintDecimals,
+ ConstraintSpace,
+ RequireViolated,
+ RequireEqViolated,
+ RequireKeysEqViolated,
+ RequireNeqViolated,
+ RequireKeysNeqViolated,
+ RequireGtViolated,
+ RequireGteViolated,
+ AccountDiscriminatorAlreadySet,
+ AccountDiscriminatorNotFound,
+ AccountDiscriminatorMismatch,
+ AccountDidNotDeserialize,
+ AccountDidNotSerialize,
+ AccountNotEnoughKeys,
+ AccountNotMutable,
+ AccountOwnedByWrongProgram,
+ InvalidProgramId,
+ InvalidProgramExecutable,
+ AccountNotSigner,
+ AccountNotSystemOwned,
+ AccountNotInitialized,
+ AccountNotProgramData,
+ AccountNotAssociatedTokenAccount,
+ AccountSysvarMismatch,
+ StateInvalidAddress,
+ Deprecated,
+]
+ANCHOR_ERROR_MAP: dict[int, AnchorError] = {
+ 100: InstructionMissing(),
+ 101: InstructionFallbackNotFound(),
+ 102: InstructionDidNotDeserialize(),
+ 103: InstructionDidNotSerialize(),
+ 1000: IdlInstructionStub(),
+ 1001: IdlInstructionInvalidProgram(),
+ 2000: ConstraintMut(),
+ 2001: ConstraintHasOne(),
+ 2002: ConstraintSigner(),
+ 2003: ConstraintRaw(),
+ 2004: ConstraintOwner(),
+ 2005: ConstraintRentExempt(),
+ 2006: ConstraintSeeds(),
+ 2007: ConstraintExecutable(),
+ 2008: ConstraintState(),
+ 2009: ConstraintAssociated(),
+ 2010: ConstraintAssociatedInit(),
+ 2011: ConstraintClose(),
+ 2012: ConstraintAddress(),
+ 2013: ConstraintZero(),
+ 2014: ConstraintTokenMint(),
+ 2015: ConstraintTokenOwner(),
+ 2016: ConstraintMintMintAuthority(),
+ 2017: ConstraintMintFreezeAuthority(),
+ 2018: ConstraintMintDecimals(),
+ 2019: ConstraintSpace(),
+ 2500: RequireViolated(),
+ 2501: RequireEqViolated(),
+ 2502: RequireKeysEqViolated(),
+ 2503: RequireNeqViolated(),
+ 2504: RequireKeysNeqViolated(),
+ 2505: RequireGtViolated(),
+ 2506: RequireGteViolated(),
+ 3000: AccountDiscriminatorAlreadySet(),
+ 3001: AccountDiscriminatorNotFound(),
+ 3002: AccountDiscriminatorMismatch(),
+ 3003: AccountDidNotDeserialize(),
+ 3004: AccountDidNotSerialize(),
+ 3005: AccountNotEnoughKeys(),
+ 3006: AccountNotMutable(),
+ 3007: AccountOwnedByWrongProgram(),
+ 3008: InvalidProgramId(),
+ 3009: InvalidProgramExecutable(),
+ 3010: AccountNotSigner(),
+ 3011: AccountNotSystemOwned(),
+ 3012: AccountNotInitialized(),
+ 3013: AccountNotProgramData(),
+ 3014: AccountNotAssociatedTokenAccount(),
+ 3015: AccountSysvarMismatch(),
+ 4000: StateInvalidAddress(),
+ 5000: Deprecated(),
+}
+
+
+def from_code(code: int) -> typing.Optional[AnchorError]:
+ maybe_err = ANCHOR_ERROR_MAP.get(code)
+ if maybe_err is None:
+ return None
+ return maybe_err
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/custom.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/custom.py
new file mode 100644
index 0000000..f92f321
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/errors/custom.py
@@ -0,0 +1,34 @@
+import typing
+from anchorpy.error import ProgramError
+
+
+class SomeError(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(6000, "Example error.")
+
+ code = 6000
+ name = "SomeError"
+ msg = "Example error."
+
+
+class OtherError(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(6001, "Another error.")
+
+ code = 6001
+ name = "OtherError"
+ msg = "Another error."
+
+
+CustomError = typing.Union[SomeError, OtherError]
+CUSTOM_ERROR_MAP: dict[int, CustomError] = {
+ 6000: SomeError(),
+ 6001: OtherError(),
+}
+
+
+def from_code(code: int) -> typing.Optional[CustomError]:
+ maybe_err = CUSTOM_ERROR_MAP.get(code)
+ if maybe_err is None:
+ return None
+ return maybe_err
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/__init__.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/__init__.py
new file mode 100644
index 0000000..dee442f
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/__init__.py
@@ -0,0 +1,17 @@
+from .initialize import initialize, InitializeAccounts
+from .initialize_with_values import (
+ initialize_with_values,
+ InitializeWithValuesArgs,
+ InitializeWithValuesAccounts,
+)
+from .initialize_with_values2 import (
+ initialize_with_values2,
+ InitializeWithValues2Args,
+ InitializeWithValues2Accounts,
+)
+from .cause_error import cause_error
+from .init_my_account import init_my_account, InitMyAccountArgs, InitMyAccountAccounts
+from .increment_state_when_present import (
+ increment_state_when_present,
+ IncrementStateWhenPresentAccounts,
+)
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/cause_error.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/cause_error.py
new file mode 100644
index 0000000..4bbd6f3
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/cause_error.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+def cause_error(
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = []
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"Ch%\x11\x02\x9bD\x11"
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/increment_state_when_present.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/increment_state_when_present.py
new file mode 100644
index 0000000..f7a41af
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/increment_state_when_present.py
@@ -0,0 +1,33 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.system_program import ID as SYS_PROGRAM_ID
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class IncrementStateWhenPresentAccounts(typing.TypedDict):
+ first_state: typing.Optional[Pubkey]
+ second_state: Pubkey
+
+
+def increment_state_when_present(
+ accounts: IncrementStateWhenPresentAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["first_state"], is_signer=False, is_writable=True)
+ if accounts["first_state"]
+ else AccountMeta(pubkey=program_id, is_signer=False, is_writable=False),
+ AccountMeta(
+ pubkey=accounts["second_state"], is_signer=False, is_writable=False
+ ),
+ AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xf1!\xdd(\xa3Jy%"
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/init_my_account.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/init_my_account.py
new file mode 100644
index 0000000..063a597
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/init_my_account.py
@@ -0,0 +1,72 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.system_program import ID as SYS_PROGRAM_ID
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class InitMyAccountArgs(typing.TypedDict):
+ seed_a: int
+
+
+layout = borsh.CStruct("seed_a" / borsh.U8)
+NESTED_NESTED_ACCOUNT_NESTED = Pubkey.find_program_address(
+ seeds=[
+ b"nested-seed",
+ b"test",
+ b"hi",
+ b"hi",
+ b"\x01",
+ b"\x02\x00\x00\x00",
+ b"\x03\x00\x00\x00\x00\x00\x00\x00",
+ ],
+ program_id=PROGRAM_ID,
+)[0]
+INIT_MY_ACCOUNT_ACCOUNTS_ACCOUNT = Pubkey.find_program_address(
+ seeds=[
+ b"another-seed",
+ b"test",
+ b"hi",
+ b"hi",
+ b"\x01",
+ b"\x02\x00\x00\x00",
+ b"\x03\x00\x00\x00\x00\x00\x00\x00",
+ ],
+ program_id=PROGRAM_ID,
+)[0]
+
+
+class InitMyAccountAccounts(typing.TypedDict):
+ base: Pubkey
+ base2: Pubkey
+
+
+def init_my_account(
+ args: InitMyAccountArgs,
+ accounts: InitMyAccountAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["base"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["base2"], is_signer=False, is_writable=False),
+ AccountMeta(
+ pubkey=INIT_MY_ACCOUNT_ACCOUNTS_ACCOUNT, is_signer=False, is_writable=False
+ ),
+ AccountMeta(
+ pubkey=NESTED_NESTED_ACCOUNT_NESTED, is_signer=False, is_writable=False
+ ),
+ AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b" ;\x05\xcd^E\xe3z"
+ encoded_args = layout.build(
+ {
+ "seed_a": args["seed_a"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize.py
new file mode 100644
index 0000000..45b0cb7
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize.py
@@ -0,0 +1,32 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.system_program import ID as SYS_PROGRAM_ID
+from solders.sysvar import RENT, CLOCK
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class InitializeAccounts(typing.TypedDict):
+ state: Pubkey
+ payer: Pubkey
+
+
+def initialize(
+ accounts: InitializeAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["state"], is_signer=True, is_writable=True),
+ AccountMeta(pubkey=CLOCK, is_signer=False, is_writable=False),
+ AccountMeta(pubkey=RENT, is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["payer"], is_signer=True, is_writable=True),
+ AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xaf\xafm\x1f\r\x98\x9b\xed"
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize_with_values.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize_with_values.py
new file mode 100644
index 0000000..ccec19f
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize_with_values.py
@@ -0,0 +1,132 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.system_program import ID as SYS_PROGRAM_ID
+from solders.sysvar import RENT, CLOCK
+from solders.instruction import Instruction, AccountMeta
+from anchorpy.borsh_extension import BorshPubkey
+from construct import Construct
+import borsh_construct as borsh
+from .. import types
+from ..program_id import PROGRAM_ID
+
+
+class InitializeWithValuesArgs(typing.TypedDict):
+ bool_field: bool
+ u8_field: int
+ i8_field: int
+ u16_field: int
+ i16_field: int
+ u32_field: int
+ i32_field: int
+ f32_field: float
+ u64_field: int
+ i64_field: int
+ f64_field: float
+ u128_field: int
+ i128_field: int
+ bytes_field: bytes
+ string_field: str
+ pubkey_field: Pubkey
+ vec_field: list[int]
+ vec_struct_field: list[types.foo_struct.FooStruct]
+ option_field: typing.Optional[bool]
+ option_struct_field: typing.Optional[types.foo_struct.FooStruct]
+ struct_field: types.foo_struct.FooStruct
+ array_field: list[bool]
+ enum_field1: types.foo_enum.FooEnumKind
+ enum_field2: types.foo_enum.FooEnumKind
+ enum_field3: types.foo_enum.FooEnumKind
+ enum_field4: types.foo_enum.FooEnumKind
+
+
+layout = borsh.CStruct(
+ "bool_field" / borsh.Bool,
+ "u8_field" / borsh.U8,
+ "i8_field" / borsh.I8,
+ "u16_field" / borsh.U16,
+ "i16_field" / borsh.I16,
+ "u32_field" / borsh.U32,
+ "i32_field" / borsh.I32,
+ "f32_field" / borsh.F32,
+ "u64_field" / borsh.U64,
+ "i64_field" / borsh.I64,
+ "f64_field" / borsh.F64,
+ "u128_field" / borsh.U128,
+ "i128_field" / borsh.I128,
+ "bytes_field" / borsh.Bytes,
+ "string_field" / borsh.String,
+ "pubkey_field" / BorshPubkey,
+ "vec_field" / borsh.Vec(typing.cast(Construct, borsh.U64)),
+ "vec_struct_field"
+ / borsh.Vec(typing.cast(Construct, types.foo_struct.FooStruct.layout)),
+ "option_field" / borsh.Option(borsh.Bool),
+ "option_struct_field" / borsh.Option(types.foo_struct.FooStruct.layout),
+ "struct_field" / types.foo_struct.FooStruct.layout,
+ "array_field" / borsh.Bool[3],
+ "enum_field1" / types.foo_enum.layout,
+ "enum_field2" / types.foo_enum.layout,
+ "enum_field3" / types.foo_enum.layout,
+ "enum_field4" / types.foo_enum.layout,
+)
+
+
+class InitializeWithValuesAccounts(typing.TypedDict):
+ state: Pubkey
+ payer: Pubkey
+
+
+def initialize_with_values(
+ args: InitializeWithValuesArgs,
+ accounts: InitializeWithValuesAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["state"], is_signer=True, is_writable=True),
+ AccountMeta(pubkey=CLOCK, is_signer=False, is_writable=False),
+ AccountMeta(pubkey=RENT, is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["payer"], is_signer=True, is_writable=True),
+ AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xdcI\x08\xd5\xb2E\xb5\x8d"
+ encoded_args = layout.build(
+ {
+ "bool_field": args["bool_field"],
+ "u8_field": args["u8_field"],
+ "i8_field": args["i8_field"],
+ "u16_field": args["u16_field"],
+ "i16_field": args["i16_field"],
+ "u32_field": args["u32_field"],
+ "i32_field": args["i32_field"],
+ "f32_field": args["f32_field"],
+ "u64_field": args["u64_field"],
+ "i64_field": args["i64_field"],
+ "f64_field": args["f64_field"],
+ "u128_field": args["u128_field"],
+ "i128_field": args["i128_field"],
+ "bytes_field": args["bytes_field"],
+ "string_field": args["string_field"],
+ "pubkey_field": args["pubkey_field"],
+ "vec_field": args["vec_field"],
+ "vec_struct_field": list(
+ map(lambda item: item.to_encodable(), args["vec_struct_field"])
+ ),
+ "option_field": args["option_field"],
+ "option_struct_field": (
+ None
+ if args["option_struct_field"] is None
+ else args["option_struct_field"].to_encodable()
+ ),
+ "struct_field": args["struct_field"].to_encodable(),
+ "array_field": args["array_field"],
+ "enum_field1": args["enum_field1"].to_encodable(),
+ "enum_field2": args["enum_field2"].to_encodable(),
+ "enum_field3": args["enum_field3"].to_encodable(),
+ "enum_field4": args["enum_field4"].to_encodable(),
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize_with_values2.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize_with_values2.py
new file mode 100644
index 0000000..6e56be8
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/instructions/initialize_with_values2.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.system_program import ID as SYS_PROGRAM_ID
+from solders.instruction import Instruction, AccountMeta
+from construct import Construct
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class InitializeWithValues2Args(typing.TypedDict):
+ vec_of_option: list[typing.Optional[int]]
+
+
+layout = borsh.CStruct(
+ "vec_of_option" / borsh.Vec(typing.cast(Construct, borsh.Option(borsh.U64)))
+)
+
+
+class InitializeWithValues2Accounts(typing.TypedDict):
+ state: Pubkey
+ payer: Pubkey
+
+
+def initialize_with_values2(
+ args: InitializeWithValues2Args,
+ accounts: InitializeWithValues2Accounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["state"], is_signer=True, is_writable=True),
+ AccountMeta(pubkey=accounts["payer"], is_signer=True, is_writable=True),
+ AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xf8\xbe\x15a\xef\x94'\xb5"
+ encoded_args = layout.build(
+ {
+ "vec_of_option": args["vec_of_option"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/program_id.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/program_id.py
new file mode 100644
index 0000000..649b93e
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/program_id.py
@@ -0,0 +1,3 @@
+from solders.pubkey import Pubkey
+
+PROGRAM_ID = Pubkey.from_string("3rTQ3R4B2PxZrAyx7EUefySPgZY8RhJf16cZajbmrzp8")
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/types/__init__.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/types/__init__.py
new file mode 100644
index 0000000..a843328
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/types/__init__.py
@@ -0,0 +1,7 @@
+import typing
+from . import bar_struct
+from .bar_struct import BarStruct, BarStructJSON
+from . import foo_struct
+from .foo_struct import FooStruct, FooStructJSON
+from . import foo_enum
+from .foo_enum import FooEnumKind, FooEnumJSON
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/types/bar_struct.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/types/bar_struct.py
new file mode 100644
index 0000000..9ab95a7
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/types/bar_struct.py
@@ -0,0 +1,33 @@
+from __future__ import annotations
+import typing
+from dataclasses import dataclass
+from construct import Container
+import borsh_construct as borsh
+
+
+class BarStructJSON(typing.TypedDict):
+ some_field: bool
+ other_field: int
+
+
+@dataclass
+class BarStruct:
+ layout: typing.ClassVar = borsh.CStruct(
+ "some_field" / borsh.Bool, "other_field" / borsh.U8
+ )
+ some_field: bool
+ other_field: int
+
+ @classmethod
+ def from_decoded(cls, obj: Container) -> "BarStruct":
+ return cls(some_field=obj.some_field, other_field=obj.other_field)
+
+ def to_encodable(self) -> dict[str, typing.Any]:
+ return {"some_field": self.some_field, "other_field": self.other_field}
+
+ def to_json(self) -> BarStructJSON:
+ return {"some_field": self.some_field, "other_field": self.other_field}
+
+ @classmethod
+ def from_json(cls, obj: BarStructJSON) -> "BarStruct":
+ return cls(some_field=obj["some_field"], other_field=obj["other_field"])
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/types/foo_enum.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/types/foo_enum.py
new file mode 100644
index 0000000..b56185f
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/types/foo_enum.py
@@ -0,0 +1,370 @@
+from __future__ import annotations
+from . import bar_struct
+import typing
+from dataclasses import dataclass
+from construct import Construct
+from anchorpy.borsh_extension import EnumForCodegen
+import borsh_construct as borsh
+
+UnnamedJSONValue = tuple[bool, int, bar_struct.BarStructJSON]
+UnnamedSingleJSONValue = tuple[bar_struct.BarStructJSON]
+
+
+class NamedJSONValue(typing.TypedDict):
+ bool_field: bool
+ u8_field: int
+ nested: bar_struct.BarStructJSON
+
+
+StructJSONValue = tuple[bar_struct.BarStructJSON]
+OptionStructJSONValue = tuple[typing.Optional[bar_struct.BarStructJSON]]
+VecStructJSONValue = tuple[list[bar_struct.BarStructJSON]]
+UnnamedValue = tuple[bool, int, bar_struct.BarStruct]
+UnnamedSingleValue = tuple[bar_struct.BarStruct]
+
+
+class NamedValue(typing.TypedDict):
+ bool_field: bool
+ u8_field: int
+ nested: bar_struct.BarStruct
+
+
+StructValue = tuple[bar_struct.BarStruct]
+OptionStructValue = tuple[typing.Optional[bar_struct.BarStruct]]
+VecStructValue = tuple[list[bar_struct.BarStruct]]
+
+
+class UnnamedJSON(typing.TypedDict):
+ value: UnnamedJSONValue
+ kind: typing.Literal["Unnamed"]
+
+
+class UnnamedSingleJSON(typing.TypedDict):
+ value: UnnamedSingleJSONValue
+ kind: typing.Literal["UnnamedSingle"]
+
+
+class NamedJSON(typing.TypedDict):
+ value: NamedJSONValue
+ kind: typing.Literal["Named"]
+
+
+class StructJSON(typing.TypedDict):
+ value: StructJSONValue
+ kind: typing.Literal["Struct"]
+
+
+class OptionStructJSON(typing.TypedDict):
+ value: OptionStructJSONValue
+ kind: typing.Literal["OptionStruct"]
+
+
+class VecStructJSON(typing.TypedDict):
+ value: VecStructJSONValue
+ kind: typing.Literal["VecStruct"]
+
+
+class NoFieldsJSON(typing.TypedDict):
+ kind: typing.Literal["NoFields"]
+
+
+@dataclass
+class Unnamed:
+ discriminator: typing.ClassVar = 0
+ kind: typing.ClassVar = "Unnamed"
+ value: UnnamedValue
+
+ def to_json(self) -> UnnamedJSON:
+ return UnnamedJSON(
+ kind="Unnamed",
+ value=(
+ self.value[0],
+ self.value[1],
+ self.value[2].to_json(),
+ ),
+ )
+
+ def to_encodable(self) -> dict:
+ return {
+ "Unnamed": {
+ "item_0": self.value[0],
+ "item_1": self.value[1],
+ "item_2": self.value[2].to_encodable(),
+ },
+ }
+
+
+@dataclass
+class UnnamedSingle:
+ discriminator: typing.ClassVar = 1
+ kind: typing.ClassVar = "UnnamedSingle"
+ value: UnnamedSingleValue
+
+ def to_json(self) -> UnnamedSingleJSON:
+ return UnnamedSingleJSON(
+ kind="UnnamedSingle",
+ value=(self.value[0].to_json(),),
+ )
+
+ def to_encodable(self) -> dict:
+ return {
+ "UnnamedSingle": {
+ "item_0": self.value[0].to_encodable(),
+ },
+ }
+
+
+@dataclass
+class Named:
+ discriminator: typing.ClassVar = 2
+ kind: typing.ClassVar = "Named"
+ value: NamedValue
+
+ def to_json(self) -> NamedJSON:
+ return NamedJSON(
+ kind="Named",
+ value={
+ "bool_field": self.value["bool_field"],
+ "u8_field": self.value["u8_field"],
+ "nested": self.value["nested"].to_json(),
+ },
+ )
+
+ def to_encodable(self) -> dict:
+ return {
+ "Named": {
+ "bool_field": self.value["bool_field"],
+ "u8_field": self.value["u8_field"],
+ "nested": self.value["nested"].to_encodable(),
+ },
+ }
+
+
+@dataclass
+class Struct:
+ discriminator: typing.ClassVar = 3
+ kind: typing.ClassVar = "Struct"
+ value: StructValue
+
+ def to_json(self) -> StructJSON:
+ return StructJSON(
+ kind="Struct",
+ value=(self.value[0].to_json(),),
+ )
+
+ def to_encodable(self) -> dict:
+ return {
+ "Struct": {
+ "item_0": self.value[0].to_encodable(),
+ },
+ }
+
+
+@dataclass
+class OptionStruct:
+ discriminator: typing.ClassVar = 4
+ kind: typing.ClassVar = "OptionStruct"
+ value: OptionStructValue
+
+ def to_json(self) -> OptionStructJSON:
+ return OptionStructJSON(
+ kind="OptionStruct",
+ value=((None if self.value[0] is None else self.value[0].to_json()),),
+ )
+
+ def to_encodable(self) -> dict:
+ return {
+ "OptionStruct": {
+ "item_0": (
+ None if self.value[0] is None else self.value[0].to_encodable()
+ ),
+ },
+ }
+
+
+@dataclass
+class VecStruct:
+ discriminator: typing.ClassVar = 5
+ kind: typing.ClassVar = "VecStruct"
+ value: VecStructValue
+
+ def to_json(self) -> VecStructJSON:
+ return VecStructJSON(
+ kind="VecStruct",
+ value=(list(map(lambda item: item.to_json(), self.value[0])),),
+ )
+
+ def to_encodable(self) -> dict:
+ return {
+ "VecStruct": {
+ "item_0": list(map(lambda item: item.to_encodable(), self.value[0])),
+ },
+ }
+
+
+@dataclass
+class NoFields:
+ discriminator: typing.ClassVar = 6
+ kind: typing.ClassVar = "NoFields"
+
+ @classmethod
+ def to_json(cls) -> NoFieldsJSON:
+ return NoFieldsJSON(
+ kind="NoFields",
+ )
+
+ @classmethod
+ def to_encodable(cls) -> dict:
+ return {
+ "NoFields": {},
+ }
+
+
+FooEnumKind = typing.Union[
+ Unnamed, UnnamedSingle, Named, Struct, OptionStruct, VecStruct, NoFields
+]
+FooEnumJSON = typing.Union[
+ UnnamedJSON,
+ UnnamedSingleJSON,
+ NamedJSON,
+ StructJSON,
+ OptionStructJSON,
+ VecStructJSON,
+ NoFieldsJSON,
+]
+
+
+def from_decoded(obj: dict) -> FooEnumKind:
+ if not isinstance(obj, dict):
+ raise ValueError("Invalid enum object")
+ if "Unnamed" in obj:
+ val = obj["Unnamed"]
+ return Unnamed(
+ (
+ val["item_0"],
+ val["item_1"],
+ bar_struct.BarStruct.from_decoded(val["item_2"]),
+ )
+ )
+ if "UnnamedSingle" in obj:
+ val = obj["UnnamedSingle"]
+ return UnnamedSingle((bar_struct.BarStruct.from_decoded(val["item_0"]),))
+ if "Named" in obj:
+ val = obj["Named"]
+ return Named(
+ NamedValue(
+ bool_field=val["bool_field"],
+ u8_field=val["u8_field"],
+ nested=bar_struct.BarStruct.from_decoded(val["nested"]),
+ )
+ )
+ if "Struct" in obj:
+ val = obj["Struct"]
+ return Struct((bar_struct.BarStruct.from_decoded(val["item_0"]),))
+ if "OptionStruct" in obj:
+ val = obj["OptionStruct"]
+ return OptionStruct(
+ (
+ (
+ None
+ if val["item_0"] is None
+ else bar_struct.BarStruct.from_decoded(val["item_0"])
+ ),
+ )
+ )
+ if "VecStruct" in obj:
+ val = obj["VecStruct"]
+ return VecStruct(
+ (
+ list(
+ map(
+ lambda item: bar_struct.BarStruct.from_decoded(item),
+ val["item_0"],
+ )
+ ),
+ )
+ )
+ if "NoFields" in obj:
+ return NoFields()
+ raise ValueError("Invalid enum object")
+
+
+def from_json(obj: FooEnumJSON) -> FooEnumKind:
+ if obj["kind"] == "Unnamed":
+ unnamed_json_value = typing.cast(UnnamedJSONValue, obj["value"])
+ return Unnamed(
+ (
+ unnamed_json_value[0],
+ unnamed_json_value[1],
+ bar_struct.BarStruct.from_json(unnamed_json_value[2]),
+ )
+ )
+ if obj["kind"] == "UnnamedSingle":
+ unnamed_single_json_value = typing.cast(UnnamedSingleJSONValue, obj["value"])
+ return UnnamedSingle(
+ (bar_struct.BarStruct.from_json(unnamed_single_json_value[0]),)
+ )
+ if obj["kind"] == "Named":
+ named_json_value = typing.cast(NamedJSONValue, obj["value"])
+ return Named(
+ NamedValue(
+ bool_field=named_json_value["bool_field"],
+ u8_field=named_json_value["u8_field"],
+ nested=bar_struct.BarStruct.from_json(named_json_value["nested"]),
+ )
+ )
+ if obj["kind"] == "Struct":
+ struct_json_value = typing.cast(StructJSONValue, obj["value"])
+ return Struct((bar_struct.BarStruct.from_json(struct_json_value[0]),))
+ if obj["kind"] == "OptionStruct":
+ option_struct_json_value = typing.cast(OptionStructJSONValue, obj["value"])
+ return OptionStruct(
+ (
+ (
+ None
+ if option_struct_json_value[0] is None
+ else bar_struct.BarStruct.from_json(option_struct_json_value[0])
+ ),
+ )
+ )
+ if obj["kind"] == "VecStruct":
+ vec_struct_json_value = typing.cast(VecStructJSONValue, obj["value"])
+ return VecStruct(
+ (
+ list(
+ map(
+ lambda item: bar_struct.BarStruct.from_json(item),
+ vec_struct_json_value[0],
+ )
+ ),
+ )
+ )
+ if obj["kind"] == "NoFields":
+ return NoFields()
+ kind = obj["kind"]
+ raise ValueError(f"Unrecognized enum kind: {kind}")
+
+
+layout = EnumForCodegen(
+ "Unnamed"
+ / borsh.CStruct(
+ "item_0" / borsh.Bool,
+ "item_1" / borsh.U8,
+ "item_2" / bar_struct.BarStruct.layout,
+ ),
+ "UnnamedSingle" / borsh.CStruct("item_0" / bar_struct.BarStruct.layout),
+ "Named"
+ / borsh.CStruct(
+ "bool_field" / borsh.Bool,
+ "u8_field" / borsh.U8,
+ "nested" / bar_struct.BarStruct.layout,
+ ),
+ "Struct" / borsh.CStruct("item_0" / bar_struct.BarStruct.layout),
+ "OptionStruct"
+ / borsh.CStruct("item_0" / borsh.Option(bar_struct.BarStruct.layout)),
+ "VecStruct"
+ / borsh.CStruct(
+ "item_0" / borsh.Vec(typing.cast(Construct, bar_struct.BarStruct.layout))
+ ),
+ "NoFields" / borsh.CStruct(),
+)
diff --git a/basics/anchorpy-main/tests/client-gen/example_program_gen/types/foo_struct.py b/basics/anchorpy-main/tests/client-gen/example_program_gen/types/foo_struct.py
new file mode 100644
index 0000000..7db49d8
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/example_program_gen/types/foo_struct.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+from . import bar_struct, foo_enum
+import typing
+from dataclasses import dataclass
+from construct import Container, Construct
+import borsh_construct as borsh
+
+
+class FooStructJSON(typing.TypedDict):
+ field1: int
+ field2: int
+ nested: bar_struct.BarStructJSON
+ vec_nested: list[bar_struct.BarStructJSON]
+ option_nested: typing.Optional[bar_struct.BarStructJSON]
+ enum_field: foo_enum.FooEnumJSON
+
+
+@dataclass
+class FooStruct:
+ layout: typing.ClassVar = borsh.CStruct(
+ "field1" / borsh.U8,
+ "field2" / borsh.U16,
+ "nested" / bar_struct.BarStruct.layout,
+ "vec_nested" / borsh.Vec(typing.cast(Construct, bar_struct.BarStruct.layout)),
+ "option_nested" / borsh.Option(bar_struct.BarStruct.layout),
+ "enum_field" / foo_enum.layout,
+ )
+ field1: int
+ field2: int
+ nested: bar_struct.BarStruct
+ vec_nested: list[bar_struct.BarStruct]
+ option_nested: typing.Optional[bar_struct.BarStruct]
+ enum_field: foo_enum.FooEnumKind
+
+ @classmethod
+ def from_decoded(cls, obj: Container) -> "FooStruct":
+ return cls(
+ field1=obj.field1,
+ field2=obj.field2,
+ nested=bar_struct.BarStruct.from_decoded(obj.nested),
+ vec_nested=list(
+ map(
+ lambda item: bar_struct.BarStruct.from_decoded(item), obj.vec_nested
+ )
+ ),
+ option_nested=(
+ None
+ if obj.option_nested is None
+ else bar_struct.BarStruct.from_decoded(obj.option_nested)
+ ),
+ enum_field=foo_enum.from_decoded(obj.enum_field),
+ )
+
+ def to_encodable(self) -> dict[str, typing.Any]:
+ return {
+ "field1": self.field1,
+ "field2": self.field2,
+ "nested": self.nested.to_encodable(),
+ "vec_nested": list(map(lambda item: item.to_encodable(), self.vec_nested)),
+ "option_nested": (
+ None
+ if self.option_nested is None
+ else self.option_nested.to_encodable()
+ ),
+ "enum_field": self.enum_field.to_encodable(),
+ }
+
+ def to_json(self) -> FooStructJSON:
+ return {
+ "field1": self.field1,
+ "field2": self.field2,
+ "nested": self.nested.to_json(),
+ "vec_nested": list(map(lambda item: item.to_json(), self.vec_nested)),
+ "option_nested": (
+ None if self.option_nested is None else self.option_nested.to_json()
+ ),
+ "enum_field": self.enum_field.to_json(),
+ }
+
+ @classmethod
+ def from_json(cls, obj: FooStructJSON) -> "FooStruct":
+ return cls(
+ field1=obj["field1"],
+ field2=obj["field2"],
+ nested=bar_struct.BarStruct.from_json(obj["nested"]),
+ vec_nested=list(
+ map(
+ lambda item: bar_struct.BarStruct.from_json(item), obj["vec_nested"]
+ )
+ ),
+ option_nested=(
+ None
+ if obj["option_nested"] is None
+ else bar_struct.BarStruct.from_json(obj["option_nested"])
+ ),
+ enum_field=foo_enum.from_json(obj["enum_field"]),
+ )
diff --git a/basics/anchorpy-main/tests/client-gen/test_client_gen.py b/basics/anchorpy-main/tests/client-gen/test_client_gen.py
new file mode 100644
index 0000000..03f2c3e
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/test_client_gen.py
@@ -0,0 +1,444 @@
+import asyncio
+import json
+from pathlib import Path
+from typing import AsyncGenerator, List
+
+from anchorpy import Provider, Wallet
+from anchorpy.pytest_plugin import localnet_fixture
+from construct import ListContainer
+from pytest import fixture, mark
+from pytest_asyncio import fixture as async_fixture
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Confirmed, Processed
+from solana.rpc.core import RPCException
+from solders.hash import Hash
+from solders.keypair import Keypair
+from solders.message import Message
+from solders.pubkey import Pubkey
+from solders.transaction import VersionedTransaction
+
+from tests.client_gen.example_program_gen.accounts import State, State2
+from tests.client_gen.example_program_gen.errors import from_tx_error
+from tests.client_gen.example_program_gen.errors.custom import SomeError
+from tests.client_gen.example_program_gen.instructions import (
+ InitializeWithValuesAccounts,
+ InitializeWithValuesArgs,
+ cause_error,
+ increment_state_when_present,
+ initialize,
+ initialize_with_values,
+ initialize_with_values2,
+)
+from tests.client_gen.example_program_gen.program_id import PROGRAM_ID
+from tests.client_gen.example_program_gen.types import BarStruct, FooStruct
+from tests.client_gen.example_program_gen.types.foo_enum import (
+ Named,
+ NoFields,
+ Struct,
+ Unnamed,
+)
+
+EXAMPLE_PROGRAM_DIR = Path("tests/client_gen/example-program")
+
+
+@fixture(scope="session")
+def event_loop():
+ """Create an instance of the default event loop for each test case."""
+ loop = asyncio.get_event_loop_policy().new_event_loop()
+ yield loop
+ loop.close()
+
+
+localnet = localnet_fixture(EXAMPLE_PROGRAM_DIR, scope="session")
+
+
+@fixture(scope="session")
+def payer(localnet) -> Keypair:
+ with (EXAMPLE_PROGRAM_DIR / ".anchor/test-ledger/faucet-keypair.json").open() as f:
+ faucet_keypair_json: List[int] = json.load(f)
+ return Keypair.from_bytes(faucet_keypair_json)
+
+
+@async_fixture(scope="session")
+async def provider(localnet, payer: Keypair) -> AsyncGenerator[Provider, None]:
+ wallet = Wallet(payer)
+ conn = AsyncClient(commitment=Processed)
+ prov = Provider(conn, wallet)
+ yield prov
+ await prov.close()
+
+
+@async_fixture(scope="session")
+async def blockhash(provider: Provider) -> Hash:
+ return (await provider.connection.get_latest_blockhash(Confirmed)).value.blockhash
+
+
+@async_fixture(scope="module")
+async def init_and_account_fetch(provider: Provider, blockhash: Hash) -> Keypair:
+ state = Keypair()
+ initialize_ix = initialize(
+ {
+ "state": state.pubkey(),
+ "payer": provider.wallet.public_key,
+ }
+ )
+ msg = Message.new_with_blockhash(
+ [initialize_ix], provider.wallet.public_key, blockhash
+ )
+ tx = VersionedTransaction(msg, [provider.wallet.payer, state])
+ await provider.send(tx)
+ return state
+
+
+@mark.asyncio
+async def test_init_and_account_fetch(
+ init_and_account_fetch: Keypair, provider: Provider
+) -> None:
+ state = init_and_account_fetch
+ vec_struct_field_enum_field_expected = Named(
+ value={
+ "bool_field": True,
+ "u8_field": 15,
+ "nested": BarStruct(some_field=True, other_field=10),
+ }
+ )
+ assert vec_struct_field_enum_field_expected.discriminator == 2
+ assert vec_struct_field_enum_field_expected.kind == "Named"
+ vec_struct_field_expected = [
+ FooStruct(
+ field1=123,
+ field2=999,
+ nested=BarStruct(some_field=True, other_field=10),
+ vec_nested=[BarStruct(some_field=True, other_field=10)],
+ option_nested=BarStruct(some_field=True, other_field=10),
+ enum_field=vec_struct_field_enum_field_expected,
+ )
+ ]
+ option_struct_field_expected = FooStruct(
+ field1=123,
+ field2=999,
+ nested=BarStruct(some_field=True, other_field=10),
+ vec_nested=[BarStruct(some_field=True, other_field=10)],
+ option_nested=BarStruct(some_field=True, other_field=10),
+ enum_field=Named(
+ value={
+ "bool_field": True,
+ "u8_field": 15,
+ "nested": BarStruct(some_field=True, other_field=10),
+ }
+ ),
+ )
+ struct_field_expected = FooStruct(
+ field1=123,
+ field2=999,
+ nested=BarStruct(some_field=True, other_field=10),
+ vec_nested=[BarStruct(some_field=True, other_field=10)],
+ option_nested=BarStruct(some_field=True, other_field=10),
+ enum_field=Named(
+ value={
+ "bool_field": True,
+ "u8_field": 15,
+ "nested": BarStruct(some_field=True, other_field=10),
+ }
+ ),
+ )
+ array_field_expected = ListContainer([True, False, True])
+ vec_field_expected = ListContainer([1, 2, 100, 1000, 18446744073709551615])
+ enum_field1_expected = Unnamed(
+ value=(False, 10, BarStruct(some_field=True, other_field=10))
+ )
+ assert enum_field1_expected.kind == "Unnamed"
+ assert enum_field1_expected.discriminator == 0
+ enum_field2_expected = Named(
+ value={
+ "bool_field": True,
+ "u8_field": 20,
+ "nested": BarStruct(some_field=True, other_field=10),
+ }
+ )
+ assert enum_field2_expected.kind == "Named"
+ assert enum_field2_expected.discriminator == 2
+ enum_field3_expected = Struct(value=(BarStruct(some_field=True, other_field=10),))
+ assert enum_field3_expected.discriminator == 3
+ assert enum_field3_expected.kind == "Struct"
+ enum_field4_expected = NoFields()
+ assert enum_field4_expected.discriminator == 6
+ assert enum_field4_expected.kind == "NoFields"
+ expected = State(
+ bool_field=True,
+ u8_field=234,
+ i8_field=-123,
+ u16_field=62345,
+ i16_field=-31234,
+ u32_field=1234567891,
+ i32_field=-1234567891,
+ f32_field=123456.5,
+ u64_field=9223372036854775817,
+ i64_field=-4611686018427387914,
+ f64_field=1234567891.345,
+ u128_field=170141183460469231731687303715884105737,
+ i128_field=-85070591730234615865843651857942052874,
+ bytes_field=b"\x01\x02\xff\xfe",
+ string_field="hello",
+ pubkey_field=Pubkey.from_string("EPZP2wrcRtMxrAPJCXVEQaYD9eH7fH7h12YqKDcd4aS7"),
+ vec_field=vec_field_expected,
+ vec_struct_field=vec_struct_field_expected,
+ option_field=None,
+ option_struct_field=option_struct_field_expected,
+ struct_field=struct_field_expected,
+ array_field=array_field_expected,
+ enum_field1=enum_field1_expected,
+ enum_field2=enum_field2_expected,
+ enum_field3=enum_field3_expected,
+ enum_field4=enum_field4_expected,
+ )
+ res = await State.fetch(provider.connection, state.pubkey())
+ assert res == expected
+ res = await State.fetch(provider.connection, state.pubkey(), program_id=PROGRAM_ID)
+ assert res == expected
+
+
+@async_fixture(scope="session")
+async def setup_fetch_multiple(
+ provider: Provider, blockhash: Hash
+) -> tuple[Keypair, Keypair]:
+ state = Keypair()
+ another_state = Keypair()
+ initialize_ixs = [
+ initialize(
+ {
+ "state": state.pubkey(),
+ "payer": provider.wallet.public_key,
+ }
+ ),
+ initialize(
+ {
+ "state": another_state.pubkey(),
+ "payer": provider.wallet.public_key,
+ }
+ ),
+ ]
+ msg = Message.new_with_blockhash(
+ initialize_ixs, provider.wallet.public_key, blockhash
+ )
+ tx = VersionedTransaction(msg, [provider.wallet.payer, state, another_state])
+ await provider.send(tx)
+ return state, another_state
+
+
+@mark.asyncio
+async def test_fetch_multiple(
+ provider: Provider, setup_fetch_multiple: tuple[Keypair, Keypair]
+) -> None:
+ state, another_state = setup_fetch_multiple
+ non_state = Keypair()
+ res = await State.fetch_multiple(
+ provider.connection,
+ [state.pubkey(), non_state.pubkey(), another_state.pubkey()],
+ )
+ assert isinstance(res[0], State)
+ assert res[1] is None
+ assert isinstance(res[2], State)
+
+
+@async_fixture(scope="session")
+async def send_instructions_with_args(
+ provider: Provider, blockhash
+) -> tuple[Keypair, Keypair]:
+ state = Keypair()
+ state2 = Keypair()
+ vec_struct_field = [
+ FooStruct(
+ field1=1,
+ field2=2,
+ nested=BarStruct(some_field=True, other_field=55),
+ vec_nested=[BarStruct(some_field=False, other_field=11)],
+ option_nested=None,
+ enum_field=Unnamed((True, 22, BarStruct(some_field=True, other_field=33))),
+ )
+ ]
+ struct_field = FooStruct(
+ field1=1,
+ field2=2,
+ nested=BarStruct(some_field=True, other_field=55),
+ vec_nested=[BarStruct(some_field=False, other_field=11)],
+ option_nested=None,
+ enum_field=NoFields(),
+ )
+ enum_field1 = Unnamed((True, 15, BarStruct(some_field=False, other_field=200)))
+ enum_field2 = Named(
+ {
+ "bool_field": True,
+ "u8_field": 128,
+ "nested": BarStruct(some_field=False, other_field=1),
+ }
+ )
+ enum_field3 = Struct((BarStruct(some_field=True, other_field=15),))
+ initialize_with_values_args = InitializeWithValuesArgs(
+ bool_field=True,
+ u8_field=253,
+ i8_field=-120,
+ u16_field=61234,
+ i16_field=-31253,
+ u32_field=1234567899,
+ i32_field=-123456789,
+ f32_field=123458.5,
+ u64_field=9223372036854775810,
+ i64_field=-4611686018427387912,
+ f64_field=1234567892.445,
+ u128_field=170141183460469231731687303715884105740,
+ i128_field=-85070591730234615865843651857942052877,
+ bytes_field=bytes([5, 10, 255]),
+ string_field="string value",
+ pubkey_field=Pubkey.from_string("GDddEKTjLBqhskzSMYph5o54VYLQfPCR3PoFqKHLJK6s"),
+ vec_field=[1, 123456789123456789],
+ vec_struct_field=vec_struct_field,
+ option_field=True,
+ option_struct_field=None,
+ struct_field=struct_field,
+ array_field=[True, True, False],
+ enum_field1=enum_field1,
+ enum_field2=enum_field2,
+ enum_field3=enum_field3,
+ enum_field4=NoFields(),
+ )
+ initialize_with_values_accounts = InitializeWithValuesAccounts(
+ state=state.pubkey(),
+ payer=provider.wallet.public_key,
+ )
+ ix1 = initialize_with_values(
+ initialize_with_values_args, initialize_with_values_accounts
+ )
+ ix2 = initialize_with_values2(
+ {"vec_of_option": [None, None, 20]},
+ {
+ "state": state2.pubkey(),
+ "payer": provider.wallet.public_key,
+ },
+ )
+ msg = Message.new_with_blockhash([ix1, ix2], provider.wallet.public_key, blockhash)
+ tx = VersionedTransaction(msg, [provider.wallet.payer, state, state2])
+ await provider.send(tx)
+ return state, state2
+
+
+@mark.asyncio
+async def test_instructions_with_args(
+ send_instructions_with_args: tuple[Keypair, Keypair], provider: Provider
+) -> None:
+ state, state2 = send_instructions_with_args
+ expected = State(
+ bool_field=True,
+ u8_field=253,
+ i8_field=-120,
+ u16_field=61234,
+ i16_field=-31253,
+ u32_field=1234567899,
+ i32_field=-123456789,
+ f32_field=123458.5,
+ u64_field=9223372036854775810,
+ i64_field=-4611686018427387912,
+ f64_field=1234567892.445,
+ u128_field=170141183460469231731687303715884105740,
+ i128_field=-85070591730234615865843651857942052877,
+ bytes_field=b"\x05\n\xff",
+ string_field="string value",
+ pubkey_field=Pubkey.from_string("GDddEKTjLBqhskzSMYph5o54VYLQfPCR3PoFqKHLJK6s"),
+ vec_field=ListContainer([1, 123456789123456789]),
+ vec_struct_field=[
+ FooStruct(
+ field1=1,
+ field2=2,
+ nested=BarStruct(some_field=True, other_field=55),
+ vec_nested=[BarStruct(some_field=False, other_field=11)],
+ option_nested=None,
+ enum_field=Unnamed(
+ value=(True, 22, BarStruct(some_field=True, other_field=33))
+ ),
+ )
+ ],
+ option_field=True,
+ option_struct_field=None,
+ struct_field=FooStruct(
+ field1=1,
+ field2=2,
+ nested=BarStruct(some_field=True, other_field=55),
+ vec_nested=[BarStruct(some_field=False, other_field=11)],
+ option_nested=None,
+ enum_field=NoFields(),
+ ),
+ array_field=ListContainer([True, True, False]),
+ enum_field1=Unnamed(
+ value=(True, 15, BarStruct(some_field=False, other_field=200))
+ ),
+ enum_field2=Named(
+ value={
+ "bool_field": True,
+ "u8_field": 128,
+ "nested": BarStruct(some_field=False, other_field=1),
+ }
+ ),
+ enum_field3=Struct(value=(BarStruct(some_field=True, other_field=15),)),
+ enum_field4=NoFields(),
+ )
+ expected2 = State2(vec_of_option=ListContainer([None, None, 20]))
+ res = await State.fetch(provider.connection, state.pubkey())
+ res2 = await State2.fetch(provider.connection, state2.pubkey())
+ assert res == expected
+ assert res2 == expected2
+
+
+@mark.asyncio
+async def test_instruction_with_optional_account(
+ send_instructions_with_args: tuple[Keypair, Keypair],
+ provider: Provider,
+ blockhash: Hash,
+) -> None:
+ def prepare_tx(ixs):
+ msg = Message.new_with_blockhash([ix], provider.wallet.public_key, blockhash)
+ tx = VersionedTransaction(msg, [provider.wallet.payer])
+ return tx
+
+ state, state2 = send_instructions_with_args
+ ix = increment_state_when_present(
+ {
+ "first_state": None,
+ "second_state": state2.pubkey(),
+ },
+ )
+ before_res = await State.fetch(provider.connection, state.pubkey())
+ assert before_res is not None
+ tx = prepare_tx(ix)
+ await provider.send(tx)
+
+ res = await State.fetch(provider.connection, state.pubkey())
+ assert res is not None
+ assert before_res.u8_field == res.u8_field
+
+ ix = increment_state_when_present(
+ {
+ "first_state": state.pubkey(),
+ "second_state": state2.pubkey(),
+ },
+ )
+
+ res = await State.fetch(provider.connection, state.pubkey())
+ tx = prepare_tx(ix)
+ await provider.send(tx)
+
+ res = await State.fetch(provider.connection, state.pubkey())
+ assert res is not None
+ assert before_res.u8_field + 1 == res.u8_field
+
+
+@mark.asyncio
+async def test_cause_error(provider: Provider, blockhash: Hash) -> None:
+ msg = Message.new_with_blockhash(
+ [cause_error()], provider.wallet.public_key, blockhash
+ )
+ tx = VersionedTransaction(msg, [provider.wallet.payer])
+ try:
+ await provider.send(tx)
+ except RPCException as exc:
+ caught = from_tx_error(exc)
+ assert isinstance(caught, SomeError)
diff --git a/basics/anchorpy-main/tests/client-gen/test_functional.py b/basics/anchorpy-main/tests/client-gen/test_functional.py
new file mode 100644
index 0000000..aa3d2db
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/test_functional.py
@@ -0,0 +1,357 @@
+import json
+from filecmp import dircmp
+from pathlib import Path
+
+from anchorpy.cli import client_gen
+from py.path import local
+from solana.rpc.core import RPCException
+from solders.pubkey import Pubkey
+from solders.rpc.errors import SendTransactionPreflightFailureMessage
+from solders.rpc.responses import SimulateTransactionResp
+
+from tests.client_gen.example_program_gen.accounts import State
+from tests.client_gen.example_program_gen.errors import from_tx_error
+from tests.client_gen.example_program_gen.errors.anchor import InvalidProgramId
+from tests.client_gen.example_program_gen.types import BarStruct, FooStruct
+from tests.client_gen.example_program_gen.types.foo_enum import (
+ Named,
+ NamedValue,
+ NoFields,
+ Struct,
+ Unnamed,
+)
+
+
+def test_quarry_mine(tmpdir: local) -> None:
+ proj_dir = Path(tmpdir)
+ out_dir = proj_dir / "generated"
+ idl_path = Path("tests/idls/quarry_mine.json")
+ client_gen(idl_path, out_dir, "placeholder")
+
+
+def test_merkle_distributor(tmpdir: local) -> None:
+ proj_dir = Path(tmpdir)
+ out_dir = proj_dir / "generated"
+ idl_path = Path("tests/idls/merkle_distributor.json")
+ client_gen(idl_path, out_dir, "placeholder")
+
+
+def test_null_err_when_cpi_fails() -> None:
+ to_dump = {
+ "jsonrpc": "2.0",
+ "error": {
+ "code": -32002,
+ "message": "",
+ "data": {
+ "err": {"InstructionError": [0, {"Custom": 3}]},
+ "logs": [
+ "Program 3rTQ3R4B2PxZrAyx7EUefySPgZY8RhJf16cZajbmrzp8 invoke [1]",
+ "Program log: Instruction: CauseError",
+ "Program 11111111111111111111111111111111 invoke [2]",
+ "Allocate: requested 1000000000000000000, max allowed 10485760",
+ "Program 11111111111111111111111111111111 failed: custom program error: 0x3",
+ "Program 3rTQ3R4B2PxZrAyx7EUefySPgZY8RhJf16cZajbmrzp8 consumed 7958 of 1400000 compute units",
+ "Program 3rTQ3R4B2PxZrAyx7EUefySPgZY8RhJf16cZajbmrzp8 failed: custom program error: 0x3",
+ ],
+ },
+ },
+ }
+ raw = json.dumps(to_dump)
+ parsed = SimulateTransactionResp.from_json(raw)
+ assert isinstance(parsed, SendTransactionPreflightFailureMessage)
+ err_mock = RPCException(parsed)
+ assert from_tx_error(err_mock) is None
+
+
+def test_parses_anchor_error() -> None:
+ to_dump = {
+ "jsonrpc": "2.0",
+ "error": {
+ "code": -32002,
+ "message": "",
+ "data": {
+ "err": {"InstructionError": [0, {"Custom": 3008}]},
+ "logs": [
+ "Program 3rTQ3R4B2PxZrAyx7EUefySPgZY8RhJf16cZajbmrzp8 invoke [1]",
+ "Program log: Instruction: CauseError",
+ "Program log: AnchorError caused by account: system_program. Error Code: InvalidProgramId. Error Number: 3008. Error Message: Program ID was not as expected.",
+ "Program log: Left:",
+ "Program log: 24S58Cp5Myf6iGx4umBNd7RgDrZ9nkKzvkfFHBMDomNa",
+ "Program log: Right:",
+ "Program log: 11111111111111111111111111111111",
+ "Program 3rTQ3R4B2PxZrAyx7EUefySPgZY8RhJf16cZajbmrzp8 consumed 5043 of 1400000 compute units",
+ "Program 3rTQ3R4B2PxZrAyx7EUefySPgZY8RhJf16cZajbmrzp8 failed: custom program error: 0xbc0",
+ ],
+ },
+ },
+ }
+ raw = json.dumps(to_dump)
+ parsed = SimulateTransactionResp.from_json(raw)
+ assert isinstance(parsed, SendTransactionPreflightFailureMessage)
+ err_mock = RPCException(parsed)
+ assert isinstance(from_tx_error(err_mock), InvalidProgramId)
+
+
+def test_json() -> None:
+ vec_struct_field = [
+ FooStruct(
+ field1=5,
+ field2=6,
+ nested=BarStruct(
+ some_field=True,
+ other_field=15,
+ ),
+ vec_nested=[
+ BarStruct(
+ some_field=True,
+ other_field=13,
+ ),
+ ],
+ option_nested=None,
+ enum_field=Unnamed(
+ (
+ False,
+ 111,
+ BarStruct(
+ some_field=False,
+ other_field=11,
+ ),
+ )
+ ),
+ ),
+ ]
+ option_struct_field = FooStruct(
+ field1=8,
+ field2=9,
+ nested=BarStruct(
+ some_field=True,
+ other_field=17,
+ ),
+ vec_nested=[
+ BarStruct(
+ some_field=True,
+ other_field=10,
+ ),
+ ],
+ option_nested=BarStruct(
+ some_field=False,
+ other_field=99,
+ ),
+ enum_field=NoFields(),
+ )
+ struct_field = FooStruct(
+ field1=11,
+ field2=12,
+ nested=BarStruct(
+ some_field=False,
+ other_field=177,
+ ),
+ vec_nested=[
+ BarStruct(
+ some_field=True,
+ other_field=15,
+ ),
+ ],
+ option_nested=BarStruct(
+ some_field=True,
+ other_field=75,
+ ),
+ enum_field=NoFields(),
+ )
+ enum_field1 = Unnamed(
+ (
+ False,
+ 157,
+ BarStruct(
+ some_field=True,
+ other_field=193,
+ ),
+ )
+ )
+ enum_field2 = Named(
+ NamedValue(
+ bool_field=False,
+ u8_field=77,
+ nested=BarStruct(
+ some_field=True,
+ other_field=100,
+ ),
+ )
+ )
+ enum_field3 = Struct(
+ (
+ BarStruct(
+ some_field=False,
+ other_field=122,
+ ),
+ )
+ )
+ state = State(
+ bool_field=True,
+ u8_field=255,
+ i8_field=-120,
+ u16_field=62000,
+ i16_field=-31000,
+ u32_field=123456789,
+ i32_field=-123456789,
+ f32_field=123456.5,
+ u64_field=9223372036854775805,
+ i64_field=4611686018427387910,
+ f64_field=1234567891.35,
+ u128_field=170141183460469231731687303715884105760,
+ i128_field=-85070591730234615865843651857942052897,
+ bytes_field=bytes([1, 255]),
+ string_field="a string",
+ pubkey_field=Pubkey.from_string("EPZP2wrcRtMxrAPJCXVEQaYD9eH7fH7h12YqKDcd4aS7"),
+ vec_field=[10, 1234567890123456],
+ vec_struct_field=vec_struct_field,
+ option_field=None,
+ option_struct_field=option_struct_field,
+ struct_field=struct_field,
+ array_field=[True, False],
+ enum_field1=enum_field1,
+ enum_field2=enum_field2,
+ enum_field3=enum_field3,
+ enum_field4=NoFields(),
+ )
+ state_json = state.to_json()
+ expected = {
+ "bool_field": True,
+ "u8_field": 255,
+ "i8_field": -120,
+ "u16_field": 62000,
+ "i16_field": -31000,
+ "u32_field": 123456789,
+ "i32_field": -123456789,
+ "f32_field": 123456.5,
+ "u64_field": 9223372036854775805,
+ "i64_field": 4611686018427387910,
+ "f64_field": 1234567891.35,
+ "u128_field": 170141183460469231731687303715884105760,
+ "i128_field": -85070591730234615865843651857942052897,
+ "bytes_field": [1, 255],
+ "string_field": "a string",
+ "pubkey_field": "EPZP2wrcRtMxrAPJCXVEQaYD9eH7fH7h12YqKDcd4aS7",
+ "vec_field": [10, 1234567890123456],
+ "vec_struct_field": [
+ {
+ "field1": 5,
+ "field2": 6,
+ "nested": {
+ "some_field": True,
+ "other_field": 15,
+ },
+ "vec_nested": [
+ {
+ "some_field": True,
+ "other_field": 13,
+ },
+ ],
+ "option_nested": None,
+ "enum_field": {
+ "kind": "Unnamed",
+ "value": (
+ False,
+ 111,
+ {
+ "some_field": False,
+ "other_field": 11,
+ },
+ ),
+ },
+ },
+ ],
+ "option_field": None,
+ "option_struct_field": {
+ "field1": 8,
+ "field2": 9,
+ "nested": {
+ "some_field": True,
+ "other_field": 17,
+ },
+ "vec_nested": [
+ {
+ "some_field": True,
+ "other_field": 10,
+ },
+ ],
+ "option_nested": {
+ "some_field": False,
+ "other_field": 99,
+ },
+ "enum_field": {
+ "kind": "NoFields",
+ },
+ },
+ "struct_field": {
+ "field1": 11,
+ "field2": 12,
+ "nested": {
+ "some_field": False,
+ "other_field": 177,
+ },
+ "vec_nested": [
+ {
+ "some_field": True,
+ "other_field": 15,
+ },
+ ],
+ "option_nested": {
+ "some_field": True,
+ "other_field": 75,
+ },
+ "enum_field": {
+ "kind": "NoFields",
+ },
+ },
+ "array_field": [True, False],
+ "enum_field1": {
+ "kind": "Unnamed",
+ "value": (
+ False,
+ 157,
+ {
+ "some_field": True,
+ "other_field": 193,
+ },
+ ),
+ },
+ "enum_field2": {
+ "kind": "Named",
+ "value": {
+ "bool_field": False,
+ "u8_field": 77,
+ "nested": {
+ "some_field": True,
+ "other_field": 100,
+ },
+ },
+ },
+ "enum_field3": {
+ "kind": "Struct",
+ "value": (
+ {
+ "some_field": False,
+ "other_field": 122,
+ },
+ ),
+ },
+ "enum_field4": {
+ "kind": "NoFields",
+ },
+ }
+ assert state_json == expected
+ state_from_json = State.from_json(state_json)
+ assert state_from_json == state
+
+
+def has_differences(dcmp: dircmp) -> bool:
+ differences = dcmp.left_only + dcmp.right_only + dcmp.diff_files
+ if differences:
+ return True
+ return any([has_differences(subdcmp) for subdcmp in dcmp.subdirs.values()])
+
+
+def test_generated_as_expected(project_dir: Path) -> None:
+ dcmp = dircmp(project_dir, "tests/client_gen/example_program_gen")
+ assert not has_differences(dcmp)
diff --git a/basics/anchorpy-main/tests/client-gen/token/__init__.py b/basics/anchorpy-main/tests/client-gen/token/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/basics/anchorpy-main/tests/client-gen/token/accounts/__init__.py b/basics/anchorpy-main/tests/client-gen/token/accounts/__init__.py
new file mode 100644
index 0000000..95f3234
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/accounts/__init__.py
@@ -0,0 +1,3 @@
+from .mint import Mint, MintJSON
+from .account import Account, AccountJSON
+from .multisig import Multisig, MultisigJSON
diff --git a/basics/anchorpy-main/tests/client-gen/token/accounts/account.py b/basics/anchorpy-main/tests/client-gen/token/accounts/account.py
new file mode 100644
index 0000000..d85015e
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/accounts/account.py
@@ -0,0 +1,133 @@
+import typing
+from dataclasses import dataclass
+from solders.pubkey import Pubkey
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Commitment
+import borsh_construct as borsh
+from anchorpy.coder.accounts import ACCOUNT_DISCRIMINATOR_SIZE
+from anchorpy.error import AccountInvalidDiscriminator
+from anchorpy.utils.rpc import get_multiple_accounts
+from anchorpy.borsh_extension import BorshPubkey, COption
+from ..program_id import PROGRAM_ID
+from .. import types
+
+
+class AccountJSON(typing.TypedDict):
+ mint: str
+ owner: str
+ amount: int
+ delegate: typing.Optional[str]
+ state: types.account_state.AccountStateJSON
+ is_native: typing.Optional[int]
+ delegated_amount: int
+ close_authority: typing.Optional[str]
+
+
+@dataclass
+class Account:
+ discriminator: typing.ClassVar = b"qB\xe06\xbcw\xf0e"
+ layout: typing.ClassVar = borsh.CStruct(
+ "mint" / BorshPubkey,
+ "owner" / BorshPubkey,
+ "amount" / borsh.U64,
+ "delegate" / COption(BorshPubkey),
+ "state" / types.account_state.layout,
+ "is_native" / COption(borsh.U64),
+ "delegated_amount" / borsh.U64,
+ "close_authority" / COption(BorshPubkey),
+ )
+ mint: Pubkey
+ owner: Pubkey
+ amount: int
+ delegate: typing.Optional[Pubkey]
+ state: types.account_state.AccountStateKind
+ is_native: typing.Optional[int]
+ delegated_amount: int
+ close_authority: typing.Optional[Pubkey]
+
+ @classmethod
+ async def fetch(
+ cls,
+ conn: AsyncClient,
+ address: Pubkey,
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.Optional["Account"]:
+ resp = await conn.get_account_info(address, commitment=commitment)
+ info = resp.value
+ if info is None:
+ return None
+ if info.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ bytes_data = info.data
+ return cls.decode(bytes_data)
+
+ @classmethod
+ async def fetch_multiple(
+ cls,
+ conn: AsyncClient,
+ addresses: list[Pubkey],
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.List[typing.Optional["Account"]]:
+ infos = await get_multiple_accounts(conn, addresses, commitment=commitment)
+ res: typing.List[typing.Optional["Account"]] = []
+ for info in infos:
+ if info is None:
+ res.append(None)
+ continue
+ if info.account.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ res.append(cls.decode(info.account.data))
+ return res
+
+ @classmethod
+ def decode(cls, data: bytes) -> "Account":
+ if data[:ACCOUNT_DISCRIMINATOR_SIZE] != cls.discriminator:
+ raise AccountInvalidDiscriminator(
+ "The discriminator for this account is invalid"
+ )
+ dec = Account.layout.parse(data[ACCOUNT_DISCRIMINATOR_SIZE:])
+ return cls(
+ mint=dec.mint,
+ owner=dec.owner,
+ amount=dec.amount,
+ delegate=dec.delegate,
+ state=types.account_state.from_decoded(dec.state),
+ is_native=dec.is_native,
+ delegated_amount=dec.delegated_amount,
+ close_authority=dec.close_authority,
+ )
+
+ def to_json(self) -> AccountJSON:
+ return {
+ "mint": str(self.mint),
+ "owner": str(self.owner),
+ "amount": self.amount,
+ "delegate": (None if self.delegate is None else str(self.delegate)),
+ "state": self.state.to_json(),
+ "is_native": self.is_native,
+ "delegated_amount": self.delegated_amount,
+ "close_authority": (
+ None if self.close_authority is None else str(self.close_authority)
+ ),
+ }
+
+ @classmethod
+ def from_json(cls, obj: AccountJSON) -> "Account":
+ return cls(
+ mint=Pubkey.from_string(obj["mint"]),
+ owner=Pubkey.from_string(obj["owner"]),
+ amount=obj["amount"],
+ delegate=(
+ None if obj["delegate"] is None else Pubkey.from_string(obj["delegate"])
+ ),
+ state=types.account_state.from_json(obj["state"]),
+ is_native=obj["is_native"],
+ delegated_amount=obj["delegated_amount"],
+ close_authority=(
+ None
+ if obj["close_authority"] is None
+ else Pubkey.from_string(obj["close_authority"])
+ ),
+ )
diff --git a/basics/anchorpy-main/tests/client-gen/token/accounts/mint.py b/basics/anchorpy-main/tests/client-gen/token/accounts/mint.py
new file mode 100644
index 0000000..8df31bb
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/accounts/mint.py
@@ -0,0 +1,118 @@
+import typing
+from dataclasses import dataclass
+from solders.pubkey import Pubkey
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Commitment
+import borsh_construct as borsh
+from anchorpy.coder.accounts import ACCOUNT_DISCRIMINATOR_SIZE
+from anchorpy.error import AccountInvalidDiscriminator
+from anchorpy.utils.rpc import get_multiple_accounts
+from anchorpy.borsh_extension import BorshPubkey, COption
+from ..program_id import PROGRAM_ID
+
+
+class MintJSON(typing.TypedDict):
+ mint_authority: typing.Optional[str]
+ supply: int
+ decimals: int
+ is_initialized: bool
+ freeze_authority: typing.Optional[str]
+
+
+@dataclass
+class Mint:
+ discriminator: typing.ClassVar = b"P\xbc\xf5\x14_\x8a9\x9c"
+ layout: typing.ClassVar = borsh.CStruct(
+ "mint_authority" / COption(BorshPubkey),
+ "supply" / borsh.U64,
+ "decimals" / borsh.U8,
+ "is_initialized" / borsh.Bool,
+ "freeze_authority" / COption(BorshPubkey),
+ )
+ mint_authority: typing.Optional[Pubkey]
+ supply: int
+ decimals: int
+ is_initialized: bool
+ freeze_authority: typing.Optional[Pubkey]
+
+ @classmethod
+ async def fetch(
+ cls,
+ conn: AsyncClient,
+ address: Pubkey,
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.Optional["Mint"]:
+ resp = await conn.get_account_info(address, commitment=commitment)
+ info = resp.value
+ if info is None:
+ return None
+ if info.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ bytes_data = info.data
+ return cls.decode(bytes_data)
+
+ @classmethod
+ async def fetch_multiple(
+ cls,
+ conn: AsyncClient,
+ addresses: list[Pubkey],
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.List[typing.Optional["Mint"]]:
+ infos = await get_multiple_accounts(conn, addresses, commitment=commitment)
+ res: typing.List[typing.Optional["Mint"]] = []
+ for info in infos:
+ if info is None:
+ res.append(None)
+ continue
+ if info.account.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ res.append(cls.decode(info.account.data))
+ return res
+
+ @classmethod
+ def decode(cls, data: bytes) -> "Mint":
+ if data[:ACCOUNT_DISCRIMINATOR_SIZE] != cls.discriminator:
+ raise AccountInvalidDiscriminator(
+ "The discriminator for this account is invalid"
+ )
+ dec = Mint.layout.parse(data[ACCOUNT_DISCRIMINATOR_SIZE:])
+ return cls(
+ mint_authority=dec.mint_authority,
+ supply=dec.supply,
+ decimals=dec.decimals,
+ is_initialized=dec.is_initialized,
+ freeze_authority=dec.freeze_authority,
+ )
+
+ def to_json(self) -> MintJSON:
+ return {
+ "mint_authority": (
+ None if self.mint_authority is None else str(self.mint_authority)
+ ),
+ "supply": self.supply,
+ "decimals": self.decimals,
+ "is_initialized": self.is_initialized,
+ "freeze_authority": (
+ None if self.freeze_authority is None else str(self.freeze_authority)
+ ),
+ }
+
+ @classmethod
+ def from_json(cls, obj: MintJSON) -> "Mint":
+ return cls(
+ mint_authority=(
+ None
+ if obj["mint_authority"] is None
+ else Pubkey.from_string(obj["mint_authority"])
+ ),
+ supply=obj["supply"],
+ decimals=obj["decimals"],
+ is_initialized=obj["is_initialized"],
+ freeze_authority=(
+ None
+ if obj["freeze_authority"] is None
+ else Pubkey.from_string(obj["freeze_authority"])
+ ),
+ )
diff --git a/basics/anchorpy-main/tests/client-gen/token/accounts/multisig.py b/basics/anchorpy-main/tests/client-gen/token/accounts/multisig.py
new file mode 100644
index 0000000..3b63a5c
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/accounts/multisig.py
@@ -0,0 +1,100 @@
+import typing
+from dataclasses import dataclass
+from solders.pubkey import Pubkey
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Commitment
+import borsh_construct as borsh
+from anchorpy.coder.accounts import ACCOUNT_DISCRIMINATOR_SIZE
+from anchorpy.error import AccountInvalidDiscriminator
+from anchorpy.utils.rpc import get_multiple_accounts
+from anchorpy.borsh_extension import BorshPubkey
+from ..program_id import PROGRAM_ID
+
+
+class MultisigJSON(typing.TypedDict):
+ m: int
+ n: int
+ is_initialized: bool
+ signers: list[str]
+
+
+@dataclass
+class Multisig:
+ discriminator: typing.ClassVar = b"\xe0ty\xbaD\xa1O\xec"
+ layout: typing.ClassVar = borsh.CStruct(
+ "m" / borsh.U8,
+ "n" / borsh.U8,
+ "is_initialized" / borsh.Bool,
+ "signers" / BorshPubkey[11],
+ )
+ m: int
+ n: int
+ is_initialized: bool
+ signers: list[Pubkey]
+
+ @classmethod
+ async def fetch(
+ cls,
+ conn: AsyncClient,
+ address: Pubkey,
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.Optional["Multisig"]:
+ resp = await conn.get_account_info(address, commitment=commitment)
+ info = resp.value
+ if info is None:
+ return None
+ if info.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ bytes_data = info.data
+ return cls.decode(bytes_data)
+
+ @classmethod
+ async def fetch_multiple(
+ cls,
+ conn: AsyncClient,
+ addresses: list[Pubkey],
+ commitment: typing.Optional[Commitment] = None,
+ program_id: Pubkey = PROGRAM_ID,
+ ) -> typing.List[typing.Optional["Multisig"]]:
+ infos = await get_multiple_accounts(conn, addresses, commitment=commitment)
+ res: typing.List[typing.Optional["Multisig"]] = []
+ for info in infos:
+ if info is None:
+ res.append(None)
+ continue
+ if info.account.owner != program_id:
+ raise ValueError("Account does not belong to this program")
+ res.append(cls.decode(info.account.data))
+ return res
+
+ @classmethod
+ def decode(cls, data: bytes) -> "Multisig":
+ if data[:ACCOUNT_DISCRIMINATOR_SIZE] != cls.discriminator:
+ raise AccountInvalidDiscriminator(
+ "The discriminator for this account is invalid"
+ )
+ dec = Multisig.layout.parse(data[ACCOUNT_DISCRIMINATOR_SIZE:])
+ return cls(
+ m=dec.m,
+ n=dec.n,
+ is_initialized=dec.is_initialized,
+ signers=dec.signers,
+ )
+
+ def to_json(self) -> MultisigJSON:
+ return {
+ "m": self.m,
+ "n": self.n,
+ "is_initialized": self.is_initialized,
+ "signers": list(map(lambda item: str(item), self.signers)),
+ }
+
+ @classmethod
+ def from_json(cls, obj: MultisigJSON) -> "Multisig":
+ return cls(
+ m=obj["m"],
+ n=obj["n"],
+ is_initialized=obj["is_initialized"],
+ signers=list(map(lambda item: Pubkey.from_string(item), obj["signers"])),
+ )
diff --git a/basics/anchorpy-main/tests/client-gen/token/errors/__init__.py b/basics/anchorpy-main/tests/client-gen/token/errors/__init__.py
new file mode 100644
index 0000000..421993d
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/errors/__init__.py
@@ -0,0 +1,29 @@
+import typing
+import re
+from solders.transaction_status import (
+ InstructionErrorCustom,
+ TransactionErrorInstructionError,
+)
+from solana.rpc.core import RPCException
+from solders.rpc.errors import SendTransactionPreflightFailureMessage
+from anchorpy.error import extract_code_and_logs
+from ..program_id import PROGRAM_ID
+from . import anchor
+from . import custom
+
+
+def from_code(code: int) -> typing.Union[custom.CustomError, anchor.AnchorError, None]:
+ return custom.from_code(code) if code >= 6000 else anchor.from_code(code)
+
+
+error_re = re.compile(r"Program (\w+) failed: custom program error: (\w+)")
+
+
+def from_tx_error(
+ error: RPCException,
+) -> typing.Union[anchor.AnchorError, custom.CustomError, None]:
+ err_info = error.args[0]
+ extracted = extract_code_and_logs(err_info, PROGRAM_ID)
+ if extracted is None:
+ return None
+ return from_code(extracted[0])
diff --git a/basics/anchorpy-main/tests/client-gen/token/errors/anchor.py b/basics/anchorpy-main/tests/client-gen/token/errors/anchor.py
new file mode 100644
index 0000000..3f266ef
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/errors/anchor.py
@@ -0,0 +1,590 @@
+import typing
+from anchorpy.error import ProgramError
+
+
+class InstructionMissing(ProgramError):
+ def __init__(self):
+ super().__init__(100, "8 byte instruction identifier not provided")
+
+ code = 100
+ name = "InstructionMissing"
+ msg = "8 byte instruction identifier not provided"
+
+
+class InstructionFallbackNotFound(ProgramError):
+ def __init__(self):
+ super().__init__(101, "Fallback functions are not supported")
+
+ code = 101
+ name = "InstructionFallbackNotFound"
+ msg = "Fallback functions are not supported"
+
+
+class InstructionDidNotDeserialize(ProgramError):
+ def __init__(self):
+ super().__init__(102, "The program could not deserialize the given instruction")
+
+ code = 102
+ name = "InstructionDidNotDeserialize"
+ msg = "The program could not deserialize the given instruction"
+
+
+class InstructionDidNotSerialize(ProgramError):
+ def __init__(self):
+ super().__init__(103, "The program could not serialize the given instruction")
+
+ code = 103
+ name = "InstructionDidNotSerialize"
+ msg = "The program could not serialize the given instruction"
+
+
+class IdlInstructionStub(ProgramError):
+ def __init__(self):
+ super().__init__(1000, "The program was compiled without idl instructions")
+
+ code = 1000
+ name = "IdlInstructionStub"
+ msg = "The program was compiled without idl instructions"
+
+
+class IdlInstructionInvalidProgram(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 1001, "The transaction was given an invalid program for the IDL instruction"
+ )
+
+ code = 1001
+ name = "IdlInstructionInvalidProgram"
+ msg = "The transaction was given an invalid program for the IDL instruction"
+
+
+class ConstraintMut(ProgramError):
+ def __init__(self):
+ super().__init__(2000, "A mut constraint was violated")
+
+ code = 2000
+ name = "ConstraintMut"
+ msg = "A mut constraint was violated"
+
+
+class ConstraintHasOne(ProgramError):
+ def __init__(self):
+ super().__init__(2001, "A has_one constraint was violated")
+
+ code = 2001
+ name = "ConstraintHasOne"
+ msg = "A has_one constraint was violated"
+
+
+class ConstraintSigner(ProgramError):
+ def __init__(self):
+ super().__init__(2002, "A signer constraint was violated")
+
+ code = 2002
+ name = "ConstraintSigner"
+ msg = "A signer constraint was violated"
+
+
+class ConstraintRaw(ProgramError):
+ def __init__(self):
+ super().__init__(2003, "A raw constraint was violated")
+
+ code = 2003
+ name = "ConstraintRaw"
+ msg = "A raw constraint was violated"
+
+
+class ConstraintOwner(ProgramError):
+ def __init__(self):
+ super().__init__(2004, "An owner constraint was violated")
+
+ code = 2004
+ name = "ConstraintOwner"
+ msg = "An owner constraint was violated"
+
+
+class ConstraintRentExempt(ProgramError):
+ def __init__(self):
+ super().__init__(2005, "A rent exempt constraint was violated")
+
+ code = 2005
+ name = "ConstraintRentExempt"
+ msg = "A rent exempt constraint was violated"
+
+
+class ConstraintSeeds(ProgramError):
+ def __init__(self):
+ super().__init__(2006, "A seeds constraint was violated")
+
+ code = 2006
+ name = "ConstraintSeeds"
+ msg = "A seeds constraint was violated"
+
+
+class ConstraintExecutable(ProgramError):
+ def __init__(self):
+ super().__init__(2007, "An executable constraint was violated")
+
+ code = 2007
+ name = "ConstraintExecutable"
+ msg = "An executable constraint was violated"
+
+
+class ConstraintState(ProgramError):
+ def __init__(self):
+ super().__init__(2008, "A state constraint was violated")
+
+ code = 2008
+ name = "ConstraintState"
+ msg = "A state constraint was violated"
+
+
+class ConstraintAssociated(ProgramError):
+ def __init__(self):
+ super().__init__(2009, "An associated constraint was violated")
+
+ code = 2009
+ name = "ConstraintAssociated"
+ msg = "An associated constraint was violated"
+
+
+class ConstraintAssociatedInit(ProgramError):
+ def __init__(self):
+ super().__init__(2010, "An associated init constraint was violated")
+
+ code = 2010
+ name = "ConstraintAssociatedInit"
+ msg = "An associated init constraint was violated"
+
+
+class ConstraintClose(ProgramError):
+ def __init__(self):
+ super().__init__(2011, "A close constraint was violated")
+
+ code = 2011
+ name = "ConstraintClose"
+ msg = "A close constraint was violated"
+
+
+class ConstraintAddress(ProgramError):
+ def __init__(self):
+ super().__init__(2012, "An address constraint was violated")
+
+ code = 2012
+ name = "ConstraintAddress"
+ msg = "An address constraint was violated"
+
+
+class ConstraintZero(ProgramError):
+ def __init__(self):
+ super().__init__(2013, "Expected zero account discriminant")
+
+ code = 2013
+ name = "ConstraintZero"
+ msg = "Expected zero account discriminant"
+
+
+class ConstraintTokenMint(ProgramError):
+ def __init__(self):
+ super().__init__(2014, "A token mint constraint was violated")
+
+ code = 2014
+ name = "ConstraintTokenMint"
+ msg = "A token mint constraint was violated"
+
+
+class ConstraintTokenOwner(ProgramError):
+ def __init__(self):
+ super().__init__(2015, "A token owner constraint was violated")
+
+ code = 2015
+ name = "ConstraintTokenOwner"
+ msg = "A token owner constraint was violated"
+
+
+class ConstraintMintMintAuthority(ProgramError):
+ def __init__(self):
+ super().__init__(2016, "A mint mint authority constraint was violated")
+
+ code = 2016
+ name = "ConstraintMintMintAuthority"
+ msg = "A mint mint authority constraint was violated"
+
+
+class ConstraintMintFreezeAuthority(ProgramError):
+ def __init__(self):
+ super().__init__(2017, "A mint freeze authority constraint was violated")
+
+ code = 2017
+ name = "ConstraintMintFreezeAuthority"
+ msg = "A mint freeze authority constraint was violated"
+
+
+class ConstraintMintDecimals(ProgramError):
+ def __init__(self):
+ super().__init__(2018, "A mint decimals constraint was violated")
+
+ code = 2018
+ name = "ConstraintMintDecimals"
+ msg = "A mint decimals constraint was violated"
+
+
+class ConstraintSpace(ProgramError):
+ def __init__(self):
+ super().__init__(2019, "A space constraint was violated")
+
+ code = 2019
+ name = "ConstraintSpace"
+ msg = "A space constraint was violated"
+
+
+class RequireViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2500, "A require expression was violated")
+
+ code = 2500
+ name = "RequireViolated"
+ msg = "A require expression was violated"
+
+
+class RequireEqViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2501, "A require_eq expression was violated")
+
+ code = 2501
+ name = "RequireEqViolated"
+ msg = "A require_eq expression was violated"
+
+
+class RequireKeysEqViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2502, "A require_keys_eq expression was violated")
+
+ code = 2502
+ name = "RequireKeysEqViolated"
+ msg = "A require_keys_eq expression was violated"
+
+
+class RequireNeqViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2503, "A require_neq expression was violated")
+
+ code = 2503
+ name = "RequireNeqViolated"
+ msg = "A require_neq expression was violated"
+
+
+class RequireKeysNeqViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2504, "A require_keys_neq expression was violated")
+
+ code = 2504
+ name = "RequireKeysNeqViolated"
+ msg = "A require_keys_neq expression was violated"
+
+
+class RequireGtViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2505, "A require_gt expression was violated")
+
+ code = 2505
+ name = "RequireGtViolated"
+ msg = "A require_gt expression was violated"
+
+
+class RequireGteViolated(ProgramError):
+ def __init__(self):
+ super().__init__(2506, "A require_gte expression was violated")
+
+ code = 2506
+ name = "RequireGteViolated"
+ msg = "A require_gte expression was violated"
+
+
+class AccountDiscriminatorAlreadySet(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 3000, "The account discriminator was already set on this account"
+ )
+
+ code = 3000
+ name = "AccountDiscriminatorAlreadySet"
+ msg = "The account discriminator was already set on this account"
+
+
+class AccountDiscriminatorNotFound(ProgramError):
+ def __init__(self):
+ super().__init__(3001, "No 8 byte discriminator was found on the account")
+
+ code = 3001
+ name = "AccountDiscriminatorNotFound"
+ msg = "No 8 byte discriminator was found on the account"
+
+
+class AccountDiscriminatorMismatch(ProgramError):
+ def __init__(self):
+ super().__init__(3002, "8 byte discriminator did not match what was expected")
+
+ code = 3002
+ name = "AccountDiscriminatorMismatch"
+ msg = "8 byte discriminator did not match what was expected"
+
+
+class AccountDidNotDeserialize(ProgramError):
+ def __init__(self):
+ super().__init__(3003, "Failed to deserialize the account")
+
+ code = 3003
+ name = "AccountDidNotDeserialize"
+ msg = "Failed to deserialize the account"
+
+
+class AccountDidNotSerialize(ProgramError):
+ def __init__(self):
+ super().__init__(3004, "Failed to serialize the account")
+
+ code = 3004
+ name = "AccountDidNotSerialize"
+ msg = "Failed to serialize the account"
+
+
+class AccountNotEnoughKeys(ProgramError):
+ def __init__(self):
+ super().__init__(3005, "Not enough account keys given to the instruction")
+
+ code = 3005
+ name = "AccountNotEnoughKeys"
+ msg = "Not enough account keys given to the instruction"
+
+
+class AccountNotMutable(ProgramError):
+ def __init__(self):
+ super().__init__(3006, "The given account is not mutable")
+
+ code = 3006
+ name = "AccountNotMutable"
+ msg = "The given account is not mutable"
+
+
+class AccountOwnedByWrongProgram(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 3007, "The given account is owned by a different program than expected"
+ )
+
+ code = 3007
+ name = "AccountOwnedByWrongProgram"
+ msg = "The given account is owned by a different program than expected"
+
+
+class InvalidProgramId(ProgramError):
+ def __init__(self):
+ super().__init__(3008, "Program ID was not as expected")
+
+ code = 3008
+ name = "InvalidProgramId"
+ msg = "Program ID was not as expected"
+
+
+class InvalidProgramExecutable(ProgramError):
+ def __init__(self):
+ super().__init__(3009, "Program account is not executable")
+
+ code = 3009
+ name = "InvalidProgramExecutable"
+ msg = "Program account is not executable"
+
+
+class AccountNotSigner(ProgramError):
+ def __init__(self):
+ super().__init__(3010, "The given account did not sign")
+
+ code = 3010
+ name = "AccountNotSigner"
+ msg = "The given account did not sign"
+
+
+class AccountNotSystemOwned(ProgramError):
+ def __init__(self):
+ super().__init__(3011, "The given account is not owned by the system program")
+
+ code = 3011
+ name = "AccountNotSystemOwned"
+ msg = "The given account is not owned by the system program"
+
+
+class AccountNotInitialized(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 3012, "The program expected this account to be already initialized"
+ )
+
+ code = 3012
+ name = "AccountNotInitialized"
+ msg = "The program expected this account to be already initialized"
+
+
+class AccountNotProgramData(ProgramError):
+ def __init__(self):
+ super().__init__(3013, "The given account is not a program data account")
+
+ code = 3013
+ name = "AccountNotProgramData"
+ msg = "The given account is not a program data account"
+
+
+class AccountNotAssociatedTokenAccount(ProgramError):
+ def __init__(self):
+ super().__init__(3014, "The given account is not the associated token account")
+
+ code = 3014
+ name = "AccountNotAssociatedTokenAccount"
+ msg = "The given account is not the associated token account"
+
+
+class AccountSysvarMismatch(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 3015, "The given public key does not match the required sysvar"
+ )
+
+ code = 3015
+ name = "AccountSysvarMismatch"
+ msg = "The given public key does not match the required sysvar"
+
+
+class StateInvalidAddress(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 4000, "The given state account does not have the correct address"
+ )
+
+ code = 4000
+ name = "StateInvalidAddress"
+ msg = "The given state account does not have the correct address"
+
+
+class Deprecated(ProgramError):
+ def __init__(self):
+ super().__init__(
+ 5000, "The API being used is deprecated and should no longer be used"
+ )
+
+ code = 5000
+ name = "Deprecated"
+ msg = "The API being used is deprecated and should no longer be used"
+
+
+AnchorError = typing.Union[
+ InstructionMissing,
+ InstructionFallbackNotFound,
+ InstructionDidNotDeserialize,
+ InstructionDidNotSerialize,
+ IdlInstructionStub,
+ IdlInstructionInvalidProgram,
+ ConstraintMut,
+ ConstraintHasOne,
+ ConstraintSigner,
+ ConstraintRaw,
+ ConstraintOwner,
+ ConstraintRentExempt,
+ ConstraintSeeds,
+ ConstraintExecutable,
+ ConstraintState,
+ ConstraintAssociated,
+ ConstraintAssociatedInit,
+ ConstraintClose,
+ ConstraintAddress,
+ ConstraintZero,
+ ConstraintTokenMint,
+ ConstraintTokenOwner,
+ ConstraintMintMintAuthority,
+ ConstraintMintFreezeAuthority,
+ ConstraintMintDecimals,
+ ConstraintSpace,
+ RequireViolated,
+ RequireEqViolated,
+ RequireKeysEqViolated,
+ RequireNeqViolated,
+ RequireKeysNeqViolated,
+ RequireGtViolated,
+ RequireGteViolated,
+ AccountDiscriminatorAlreadySet,
+ AccountDiscriminatorNotFound,
+ AccountDiscriminatorMismatch,
+ AccountDidNotDeserialize,
+ AccountDidNotSerialize,
+ AccountNotEnoughKeys,
+ AccountNotMutable,
+ AccountOwnedByWrongProgram,
+ InvalidProgramId,
+ InvalidProgramExecutable,
+ AccountNotSigner,
+ AccountNotSystemOwned,
+ AccountNotInitialized,
+ AccountNotProgramData,
+ AccountNotAssociatedTokenAccount,
+ AccountSysvarMismatch,
+ StateInvalidAddress,
+ Deprecated,
+]
+ANCHOR_ERROR_MAP: dict[int, AnchorError] = {
+ 100: InstructionMissing(),
+ 101: InstructionFallbackNotFound(),
+ 102: InstructionDidNotDeserialize(),
+ 103: InstructionDidNotSerialize(),
+ 1000: IdlInstructionStub(),
+ 1001: IdlInstructionInvalidProgram(),
+ 2000: ConstraintMut(),
+ 2001: ConstraintHasOne(),
+ 2002: ConstraintSigner(),
+ 2003: ConstraintRaw(),
+ 2004: ConstraintOwner(),
+ 2005: ConstraintRentExempt(),
+ 2006: ConstraintSeeds(),
+ 2007: ConstraintExecutable(),
+ 2008: ConstraintState(),
+ 2009: ConstraintAssociated(),
+ 2010: ConstraintAssociatedInit(),
+ 2011: ConstraintClose(),
+ 2012: ConstraintAddress(),
+ 2013: ConstraintZero(),
+ 2014: ConstraintTokenMint(),
+ 2015: ConstraintTokenOwner(),
+ 2016: ConstraintMintMintAuthority(),
+ 2017: ConstraintMintFreezeAuthority(),
+ 2018: ConstraintMintDecimals(),
+ 2019: ConstraintSpace(),
+ 2500: RequireViolated(),
+ 2501: RequireEqViolated(),
+ 2502: RequireKeysEqViolated(),
+ 2503: RequireNeqViolated(),
+ 2504: RequireKeysNeqViolated(),
+ 2505: RequireGtViolated(),
+ 2506: RequireGteViolated(),
+ 3000: AccountDiscriminatorAlreadySet(),
+ 3001: AccountDiscriminatorNotFound(),
+ 3002: AccountDiscriminatorMismatch(),
+ 3003: AccountDidNotDeserialize(),
+ 3004: AccountDidNotSerialize(),
+ 3005: AccountNotEnoughKeys(),
+ 3006: AccountNotMutable(),
+ 3007: AccountOwnedByWrongProgram(),
+ 3008: InvalidProgramId(),
+ 3009: InvalidProgramExecutable(),
+ 3010: AccountNotSigner(),
+ 3011: AccountNotSystemOwned(),
+ 3012: AccountNotInitialized(),
+ 3013: AccountNotProgramData(),
+ 3014: AccountNotAssociatedTokenAccount(),
+ 3015: AccountSysvarMismatch(),
+ 4000: StateInvalidAddress(),
+ 5000: Deprecated(),
+}
+
+
+def from_code(code: int) -> typing.Optional[AnchorError]:
+ maybe_err = ANCHOR_ERROR_MAP.get(code)
+ if maybe_err is None:
+ return None
+ return maybe_err
diff --git a/basics/anchorpy-main/tests/client-gen/token/errors/custom.py b/basics/anchorpy-main/tests/client-gen/token/errors/custom.py
new file mode 100644
index 0000000..15cabe4
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/errors/custom.py
@@ -0,0 +1,239 @@
+import typing
+from anchorpy.error import ProgramError
+
+
+class NotRentExempt(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(0, "Lamport balance below rent-exempt threshold")
+
+ code = 0
+ name = "NotRentExempt"
+ msg = "Lamport balance below rent-exempt threshold"
+
+
+class InsufficientFunds(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(1, "Insufficient funds")
+
+ code = 1
+ name = "InsufficientFunds"
+ msg = "Insufficient funds"
+
+
+class InvalidMint(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(2, "Invalid Mint")
+
+ code = 2
+ name = "InvalidMint"
+ msg = "Invalid Mint"
+
+
+class MintMismatch(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(3, "Account not associated with this Mint")
+
+ code = 3
+ name = "MintMismatch"
+ msg = "Account not associated with this Mint"
+
+
+class OwnerMismatch(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(4, "Owner does not match")
+
+ code = 4
+ name = "OwnerMismatch"
+ msg = "Owner does not match"
+
+
+class FixedSupply(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(5, "Fixed supply")
+
+ code = 5
+ name = "FixedSupply"
+ msg = "Fixed supply"
+
+
+class AlreadyInUse(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(6, "Already in use")
+
+ code = 6
+ name = "AlreadyInUse"
+ msg = "Already in use"
+
+
+class InvalidNumberOfProvidedSigners(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(7, "Invalid number of provided signers")
+
+ code = 7
+ name = "InvalidNumberOfProvidedSigners"
+ msg = "Invalid number of provided signers"
+
+
+class InvalidNumberOfRequiredSigners(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(8, "Invalid number of required signers")
+
+ code = 8
+ name = "InvalidNumberOfRequiredSigners"
+ msg = "Invalid number of required signers"
+
+
+class UninitializedState(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(9, "State is unititialized")
+
+ code = 9
+ name = "UninitializedState"
+ msg = "State is unititialized"
+
+
+class NativeNotSupported(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(10, "Instruction does not support native tokens")
+
+ code = 10
+ name = "NativeNotSupported"
+ msg = "Instruction does not support native tokens"
+
+
+class NonNativeHasBalance(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(
+ 11, "Non-native account can only be closed if its balance is zero"
+ )
+
+ code = 11
+ name = "NonNativeHasBalance"
+ msg = "Non-native account can only be closed if its balance is zero"
+
+
+class InvalidInstruction(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(12, "Invalid instruction")
+
+ code = 12
+ name = "InvalidInstruction"
+ msg = "Invalid instruction"
+
+
+class InvalidState(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(13, "State is invalid for requested operation")
+
+ code = 13
+ name = "InvalidState"
+ msg = "State is invalid for requested operation"
+
+
+class Overflow(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(14, "Operation overflowed")
+
+ code = 14
+ name = "Overflow"
+ msg = "Operation overflowed"
+
+
+class AuthorityTypeNotSupported(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(15, "Account does not support specified authority type")
+
+ code = 15
+ name = "AuthorityTypeNotSupported"
+ msg = "Account does not support specified authority type"
+
+
+class MintCannotFreeze(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(16, "This token mint cannot freeze accounts")
+
+ code = 16
+ name = "MintCannotFreeze"
+ msg = "This token mint cannot freeze accounts"
+
+
+class AccountFrozen(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(17, "Account is frozen")
+
+ code = 17
+ name = "AccountFrozen"
+ msg = "Account is frozen"
+
+
+class MintDecimalsMismatch(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(
+ 18, "The provided decimals value different from the Mint decimals"
+ )
+
+ code = 18
+ name = "MintDecimalsMismatch"
+ msg = "The provided decimals value different from the Mint decimals"
+
+
+class NonNativeNotSupported(ProgramError):
+ def __init__(self) -> None:
+ super().__init__(19, "Instruction does not support non-native tokens")
+
+ code = 19
+ name = "NonNativeNotSupported"
+ msg = "Instruction does not support non-native tokens"
+
+
+CustomError = typing.Union[
+ NotRentExempt,
+ InsufficientFunds,
+ InvalidMint,
+ MintMismatch,
+ OwnerMismatch,
+ FixedSupply,
+ AlreadyInUse,
+ InvalidNumberOfProvidedSigners,
+ InvalidNumberOfRequiredSigners,
+ UninitializedState,
+ NativeNotSupported,
+ NonNativeHasBalance,
+ InvalidInstruction,
+ InvalidState,
+ Overflow,
+ AuthorityTypeNotSupported,
+ MintCannotFreeze,
+ AccountFrozen,
+ MintDecimalsMismatch,
+ NonNativeNotSupported,
+]
+CUSTOM_ERROR_MAP: dict[int, CustomError] = {
+ 0: NotRentExempt(),
+ 1: InsufficientFunds(),
+ 2: InvalidMint(),
+ 3: MintMismatch(),
+ 4: OwnerMismatch(),
+ 5: FixedSupply(),
+ 6: AlreadyInUse(),
+ 7: InvalidNumberOfProvidedSigners(),
+ 8: InvalidNumberOfRequiredSigners(),
+ 9: UninitializedState(),
+ 10: NativeNotSupported(),
+ 11: NonNativeHasBalance(),
+ 12: InvalidInstruction(),
+ 13: InvalidState(),
+ 14: Overflow(),
+ 15: AuthorityTypeNotSupported(),
+ 16: MintCannotFreeze(),
+ 17: AccountFrozen(),
+ 18: MintDecimalsMismatch(),
+ 19: NonNativeNotSupported(),
+}
+
+
+def from_code(code: int) -> typing.Optional[CustomError]:
+ maybe_err = CUSTOM_ERROR_MAP.get(code)
+ if maybe_err is None:
+ return None
+ return maybe_err
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/__init__.py b/basics/anchorpy-main/tests/client-gen/token/instructions/__init__.py
new file mode 100644
index 0000000..7167c3b
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/__init__.py
@@ -0,0 +1,60 @@
+from .initialize_mint import initialize_mint, InitializeMintArgs, InitializeMintAccounts
+from .initialize_account import initialize_account, InitializeAccountAccounts
+from .initialize_multisig import (
+ initialize_multisig,
+ InitializeMultisigArgs,
+ InitializeMultisigAccounts,
+)
+from .transfer import transfer, TransferArgs, TransferAccounts
+from .approve import approve, ApproveArgs, ApproveAccounts
+from .revoke import revoke, RevokeAccounts
+from .set_authority import set_authority, SetAuthorityArgs, SetAuthorityAccounts
+from .mint_to import mint_to, MintToArgs, MintToAccounts
+from .burn import burn, BurnArgs, BurnAccounts
+from .close_account import close_account, CloseAccountAccounts
+from .freeze_account import freeze_account, FreezeAccountAccounts
+from .thaw_account import thaw_account, ThawAccountAccounts
+from .transfer_checked import (
+ transfer_checked,
+ TransferCheckedArgs,
+ TransferCheckedAccounts,
+)
+from .approve_checked import approve_checked, ApproveCheckedArgs, ApproveCheckedAccounts
+from .mint_to_checked import mint_to_checked, MintToCheckedArgs, MintToCheckedAccounts
+from .burn_checked import burn_checked, BurnCheckedArgs, BurnCheckedAccounts
+from .initialize_account2 import (
+ initialize_account2,
+ InitializeAccount2Args,
+ InitializeAccount2Accounts,
+)
+from .sync_native import sync_native, SyncNativeAccounts
+from .initialize_account3 import (
+ initialize_account3,
+ InitializeAccount3Args,
+ InitializeAccount3Accounts,
+)
+from .initialize_multisig2 import (
+ initialize_multisig2,
+ InitializeMultisig2Args,
+ InitializeMultisig2Accounts,
+)
+from .initialize_mint2 import (
+ initialize_mint2,
+ InitializeMint2Args,
+ InitializeMint2Accounts,
+)
+from .get_account_data_size import get_account_data_size, GetAccountDataSizeAccounts
+from .initialize_immutable_owner import (
+ initialize_immutable_owner,
+ InitializeImmutableOwnerAccounts,
+)
+from .amount_to_ui_amount import (
+ amount_to_ui_amount,
+ AmountToUiAmountArgs,
+ AmountToUiAmountAccounts,
+)
+from .ui_amount_to_amount import (
+ ui_amount_to_amount,
+ UiAmountToAmountArgs,
+ UiAmountToAmountAccounts,
+)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/amount_to_ui_amount.py b/basics/anchorpy-main/tests/client-gen/token/instructions/amount_to_ui_amount.py
new file mode 100644
index 0000000..a19f397
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/amount_to_ui_amount.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class AmountToUiAmountArgs(typing.TypedDict):
+ amount: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64)
+
+
+class AmountToUiAmountAccounts(typing.TypedDict):
+ mint: Pubkey
+
+
+def amount_to_ui_amount(
+ args: AmountToUiAmountArgs,
+ accounts: AmountToUiAmountAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False)
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xa0\x91\xc8b\xf2\x9c\x1eZ"
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/approve.py b/basics/anchorpy-main/tests/client-gen/token/instructions/approve.py
new file mode 100644
index 0000000..2916385
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/approve.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class ApproveArgs(typing.TypedDict):
+ amount: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64)
+
+
+class ApproveAccounts(typing.TypedDict):
+ source: Pubkey
+ delegate: Pubkey
+ owner: Pubkey
+
+
+def approve(
+ args: ApproveArgs,
+ accounts: ApproveAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["source"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["delegate"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"EJ\xd9$suaL"
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/approve_checked.py b/basics/anchorpy-main/tests/client-gen/token/instructions/approve_checked.py
new file mode 100644
index 0000000..b734d0a
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/approve_checked.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class ApproveCheckedArgs(typing.TypedDict):
+ amount: int
+ decimals: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64, "decimals" / borsh.U8)
+
+
+class ApproveCheckedAccounts(typing.TypedDict):
+ source: Pubkey
+ mint: Pubkey
+ delegate: Pubkey
+ owner: Pubkey
+
+
+def approve_checked(
+ args: ApproveCheckedArgs,
+ accounts: ApproveCheckedAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["source"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["delegate"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"/\xc5\xfe*:\xc9:m"
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ "decimals": args["decimals"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/burn.py b/basics/anchorpy-main/tests/client-gen/token/instructions/burn.py
new file mode 100644
index 0000000..be55863
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/burn.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class BurnArgs(typing.TypedDict):
+ amount: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64)
+
+
+class BurnAccounts(typing.TypedDict):
+ account: Pubkey
+ mint: Pubkey
+ authority: Pubkey
+
+
+def burn(
+ args: BurnArgs,
+ accounts: BurnAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["authority"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"tn\x1d8k\xdb*]"
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/burn_checked.py b/basics/anchorpy-main/tests/client-gen/token/instructions/burn_checked.py
new file mode 100644
index 0000000..913224a
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/burn_checked.py
@@ -0,0 +1,44 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class BurnCheckedArgs(typing.TypedDict):
+ amount: int
+ decimals: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64, "decimals" / borsh.U8)
+
+
+class BurnCheckedAccounts(typing.TypedDict):
+ account: Pubkey
+ mint: Pubkey
+ authority: Pubkey
+
+
+def burn_checked(
+ args: BurnCheckedArgs,
+ accounts: BurnCheckedAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["authority"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xc6y\xc8fx\xd0\x9b\xb2"
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ "decimals": args["decimals"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/close_account.py b/basics/anchorpy-main/tests/client-gen/token/instructions/close_account.py
new file mode 100644
index 0000000..c6bf6de
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/close_account.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class CloseAccountAccounts(typing.TypedDict):
+ account: Pubkey
+ destination: Pubkey
+ owner: Pubkey
+
+
+def close_account(
+ accounts: CloseAccountAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["destination"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b'}\xff\x95\x0en"H\x18'
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/freeze_account.py b/basics/anchorpy-main/tests/client-gen/token/instructions/freeze_account.py
new file mode 100644
index 0000000..921cded
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/freeze_account.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class FreezeAccountAccounts(typing.TypedDict):
+ account: Pubkey
+ mint: Pubkey
+ owner: Pubkey
+
+
+def freeze_account(
+ accounts: FreezeAccountAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xfdKR\x85\xa7\xee+\x82"
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/get_account_data_size.py b/basics/anchorpy-main/tests/client-gen/token/instructions/get_account_data_size.py
new file mode 100644
index 0000000..f5a55f4
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/get_account_data_size.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class GetAccountDataSizeAccounts(typing.TypedDict):
+ mint: Pubkey
+
+
+def get_account_data_size(
+ accounts: GetAccountDataSizeAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False)
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\x10\xb1\xd2\x80\x15-o\x1f"
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account.py b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account.py
new file mode 100644
index 0000000..288bef6
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.sysvar import RENT
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class InitializeAccountAccounts(typing.TypedDict):
+ account: Pubkey
+ mint: Pubkey
+ owner: Pubkey
+
+
+def initialize_account(
+ accounts: InitializeAccountAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["owner"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=RENT, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"Jsc]\xc5Eg\x07"
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account2.py b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account2.py
new file mode 100644
index 0000000..b3257fb
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account2.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.sysvar import RENT
+from solders.instruction import Instruction, AccountMeta
+from anchorpy.borsh_extension import BorshPubkey
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class InitializeAccount2Args(typing.TypedDict):
+ owner: Pubkey
+
+
+layout = borsh.CStruct("owner" / BorshPubkey)
+
+
+class InitializeAccount2Accounts(typing.TypedDict):
+ account: Pubkey
+ mint: Pubkey
+
+
+def initialize_account2(
+ args: InitializeAccount2Args,
+ accounts: InitializeAccount2Accounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=RENT, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\x08\xb6\x95\x90\xb9\x1f\xd1i"
+ encoded_args = layout.build(
+ {
+ "owner": args["owner"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account3.py b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account3.py
new file mode 100644
index 0000000..83427fb
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_account3.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from anchorpy.borsh_extension import BorshPubkey
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class InitializeAccount3Args(typing.TypedDict):
+ owner: Pubkey
+
+
+layout = borsh.CStruct("owner" / BorshPubkey)
+
+
+class InitializeAccount3Accounts(typing.TypedDict):
+ account: Pubkey
+ mint: Pubkey
+
+
+def initialize_account3(
+ args: InitializeAccount3Args,
+ accounts: InitializeAccount3Accounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\x17\x8e\x8c\x87\x15\xa0\x85@"
+ encoded_args = layout.build(
+ {
+ "owner": args["owner"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_immutable_owner.py b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_immutable_owner.py
new file mode 100644
index 0000000..ffea985
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_immutable_owner.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class InitializeImmutableOwnerAccounts(typing.TypedDict):
+ account: Pubkey
+
+
+def initialize_immutable_owner(
+ accounts: InitializeImmutableOwnerAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True)
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b'\x8d2\x0f,\xc3\xf7"<'
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_mint.py b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_mint.py
new file mode 100644
index 0000000..c2b94af
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_mint.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.sysvar import RENT
+from solders.instruction import Instruction, AccountMeta
+from anchorpy.borsh_extension import BorshPubkey, COption
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class InitializeMintArgs(typing.TypedDict):
+ decimals: int
+ mint_authority: Pubkey
+ freeze_authority: typing.Optional[Pubkey]
+
+
+layout = borsh.CStruct(
+ "decimals" / borsh.U8,
+ "mint_authority" / BorshPubkey,
+ "freeze_authority" / COption(BorshPubkey),
+)
+
+
+class InitializeMintAccounts(typing.TypedDict):
+ mint: Pubkey
+
+
+def initialize_mint(
+ args: InitializeMintArgs,
+ accounts: InitializeMintAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=RENT, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xd1*\xc3\x04\x81U\xd1,"
+ encoded_args = layout.build(
+ {
+ "decimals": args["decimals"],
+ "mint_authority": args["mint_authority"],
+ "freeze_authority": args["freeze_authority"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_mint2.py b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_mint2.py
new file mode 100644
index 0000000..ef12ee6
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_mint2.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from anchorpy.borsh_extension import BorshPubkey, COption
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class InitializeMint2Args(typing.TypedDict):
+ decimals: int
+ mint_authority: Pubkey
+ freeze_authority: typing.Optional[Pubkey]
+
+
+layout = borsh.CStruct(
+ "decimals" / borsh.U8,
+ "mint_authority" / BorshPubkey,
+ "freeze_authority" / COption(BorshPubkey),
+)
+
+
+class InitializeMint2Accounts(typing.TypedDict):
+ mint: Pubkey
+
+
+def initialize_mint2(
+ args: InitializeMint2Args,
+ accounts: InitializeMint2Accounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=True)
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"_l\xc6\xd2H\xf3\x8f\xeb"
+ encoded_args = layout.build(
+ {
+ "decimals": args["decimals"],
+ "mint_authority": args["mint_authority"],
+ "freeze_authority": args["freeze_authority"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_multisig.py b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_multisig.py
new file mode 100644
index 0000000..e5a7374
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_multisig.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.sysvar import RENT
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class InitializeMultisigArgs(typing.TypedDict):
+ m: int
+
+
+layout = borsh.CStruct("m" / borsh.U8)
+
+
+class InitializeMultisigAccounts(typing.TypedDict):
+ multisig: Pubkey
+
+
+def initialize_multisig(
+ args: InitializeMultisigArgs,
+ accounts: InitializeMultisigAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["multisig"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=RENT, is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xdc\x82u\x15\x1b\xe3N\xd5"
+ encoded_args = layout.build(
+ {
+ "m": args["m"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_multisig2.py b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_multisig2.py
new file mode 100644
index 0000000..2d77574
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/initialize_multisig2.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class InitializeMultisig2Args(typing.TypedDict):
+ m: int
+
+
+layout = borsh.CStruct("m" / borsh.U8)
+
+
+class InitializeMultisig2Accounts(typing.TypedDict):
+ multisig: Pubkey
+ signer: Pubkey
+
+
+def initialize_multisig2(
+ args: InitializeMultisig2Args,
+ accounts: InitializeMultisig2Accounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["multisig"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["signer"], is_signer=False, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"Q\xefI'\x1b\x94\x02\x92"
+ encoded_args = layout.build(
+ {
+ "m": args["m"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/mint_to.py b/basics/anchorpy-main/tests/client-gen/token/instructions/mint_to.py
new file mode 100644
index 0000000..947566c
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/mint_to.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class MintToArgs(typing.TypedDict):
+ amount: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64)
+
+
+class MintToAccounts(typing.TypedDict):
+ mint: Pubkey
+ account: Pubkey
+ owner: Pubkey
+
+
+def mint_to(
+ args: MintToArgs,
+ accounts: MintToAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b'\xf1"0\xba%\xb3{\xc0'
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/mint_to_checked.py b/basics/anchorpy-main/tests/client-gen/token/instructions/mint_to_checked.py
new file mode 100644
index 0000000..f4ba48c
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/mint_to_checked.py
@@ -0,0 +1,44 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class MintToCheckedArgs(typing.TypedDict):
+ amount: int
+ decimals: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64, "decimals" / borsh.U8)
+
+
+class MintToCheckedAccounts(typing.TypedDict):
+ mint: Pubkey
+ account: Pubkey
+ owner: Pubkey
+
+
+def mint_to_checked(
+ args: MintToCheckedArgs,
+ accounts: MintToCheckedAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xe5\xec$\xf0v\xe1-}"
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ "decimals": args["decimals"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/revoke.py b/basics/anchorpy-main/tests/client-gen/token/instructions/revoke.py
new file mode 100644
index 0000000..54009f8
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/revoke.py
@@ -0,0 +1,27 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class RevokeAccounts(typing.TypedDict):
+ source: Pubkey
+ owner: Pubkey
+
+
+def revoke(
+ accounts: RevokeAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["source"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b'\xaa\x17\x1f"\x85\xad]\xf2'
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/set_authority.py b/basics/anchorpy-main/tests/client-gen/token/instructions/set_authority.py
new file mode 100644
index 0000000..51ad91c
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/set_authority.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from anchorpy.borsh_extension import BorshPubkey, COption
+import borsh_construct as borsh
+from .. import types
+from ..program_id import PROGRAM_ID
+
+
+class SetAuthorityArgs(typing.TypedDict):
+ authority_type: types.authority_type.AuthorityTypeKind
+ new_authority: typing.Optional[Pubkey]
+
+
+layout = borsh.CStruct(
+ "authority_type" / types.authority_type.layout,
+ "new_authority" / COption(BorshPubkey),
+)
+
+
+class SetAuthorityAccounts(typing.TypedDict):
+ owned: Pubkey
+ owner: Pubkey
+ signer: Pubkey
+
+
+def set_authority(
+ args: SetAuthorityArgs,
+ accounts: SetAuthorityAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["owned"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ AccountMeta(pubkey=accounts["signer"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\x85\xfa%\x15n\xa3\x1ay"
+ encoded_args = layout.build(
+ {
+ "authority_type": args["authority_type"].to_encodable(),
+ "new_authority": args["new_authority"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/sync_native.py b/basics/anchorpy-main/tests/client-gen/token/instructions/sync_native.py
new file mode 100644
index 0000000..d615229
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/sync_native.py
@@ -0,0 +1,25 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class SyncNativeAccounts(typing.TypedDict):
+ account: Pubkey
+
+
+def sync_native(
+ accounts: SyncNativeAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True)
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\x9b\xdb$$\xef\x80\x15A"
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/thaw_account.py b/basics/anchorpy-main/tests/client-gen/token/instructions/thaw_account.py
new file mode 100644
index 0000000..fab2d9c
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/thaw_account.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+from ..program_id import PROGRAM_ID
+
+
+class ThawAccountAccounts(typing.TypedDict):
+ account: Pubkey
+ mint: Pubkey
+ owner: Pubkey
+
+
+def thaw_account(
+ accounts: ThawAccountAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["account"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["owner"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"s\x98O\xd5\xd5\xa9\xb8#"
+ encoded_args = b""
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/transfer.py b/basics/anchorpy-main/tests/client-gen/token/instructions/transfer.py
new file mode 100644
index 0000000..a24edfb
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/transfer.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class TransferArgs(typing.TypedDict):
+ amount: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64)
+
+
+class TransferAccounts(typing.TypedDict):
+ source: Pubkey
+ destination: Pubkey
+ authority: Pubkey
+
+
+def transfer(
+ args: TransferArgs,
+ accounts: TransferAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["source"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["destination"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["authority"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xa34\xc8\xe7\x8c\x03E\xba"
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/transfer_checked.py b/basics/anchorpy-main/tests/client-gen/token/instructions/transfer_checked.py
new file mode 100644
index 0000000..429e631
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/transfer_checked.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class TransferCheckedArgs(typing.TypedDict):
+ amount: int
+ decimals: int
+
+
+layout = borsh.CStruct("amount" / borsh.U64, "decimals" / borsh.U8)
+
+
+class TransferCheckedAccounts(typing.TypedDict):
+ source: Pubkey
+ mint: Pubkey
+ destination: Pubkey
+ authority: Pubkey
+
+
+def transfer_checked(
+ args: TransferCheckedArgs,
+ accounts: TransferCheckedAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["source"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False),
+ AccountMeta(pubkey=accounts["destination"], is_signer=False, is_writable=True),
+ AccountMeta(pubkey=accounts["authority"], is_signer=True, is_writable=False),
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"w\xfa\xca\x18\xfd\x87\xf4y"
+ encoded_args = layout.build(
+ {
+ "amount": args["amount"],
+ "decimals": args["decimals"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/instructions/ui_amount_to_amount.py b/basics/anchorpy-main/tests/client-gen/token/instructions/ui_amount_to_amount.py
new file mode 100644
index 0000000..bc72ac8
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/instructions/ui_amount_to_amount.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+import typing
+from solders.pubkey import Pubkey
+from solders.instruction import Instruction, AccountMeta
+import borsh_construct as borsh
+from ..program_id import PROGRAM_ID
+
+
+class UiAmountToAmountArgs(typing.TypedDict):
+ ui_amount: str
+
+
+layout = borsh.CStruct(borsh.String)
+
+
+class UiAmountToAmountAccounts(typing.TypedDict):
+ mint: Pubkey
+
+
+def ui_amount_to_amount(
+ args: UiAmountToAmountArgs,
+ accounts: UiAmountToAmountAccounts,
+ program_id: Pubkey = PROGRAM_ID,
+ remaining_accounts: typing.Optional[typing.List[AccountMeta]] = None,
+) -> Instruction:
+ keys: list[AccountMeta] = [
+ AccountMeta(pubkey=accounts["mint"], is_signer=False, is_writable=False)
+ ]
+ if remaining_accounts is not None:
+ keys += remaining_accounts
+ identifier = b"\xad\xf3@\x04g\x1f84"
+ encoded_args = layout.build(
+ {
+ "ui_amount": args["ui_amount"],
+ }
+ )
+ data = identifier + encoded_args
+ return Instruction(program_id, data, keys)
diff --git a/basics/anchorpy-main/tests/client-gen/token/program_id.py b/basics/anchorpy-main/tests/client-gen/token/program_id.py
new file mode 100644
index 0000000..6f3e9ff
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/program_id.py
@@ -0,0 +1,3 @@
+from solders.pubkey import Pubkey
+
+PROGRAM_ID = Pubkey.from_string("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
diff --git a/basics/anchorpy-main/tests/client-gen/token/types/__init__.py b/basics/anchorpy-main/tests/client-gen/token/types/__init__.py
new file mode 100644
index 0000000..a0a21a6
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/types/__init__.py
@@ -0,0 +1,5 @@
+import typing
+from . import account_state
+from .account_state import AccountStateKind, AccountStateJSON
+from . import authority_type
+from .authority_type import AuthorityTypeKind, AuthorityTypeJSON
diff --git a/basics/anchorpy-main/tests/client-gen/token/types/account_state.py b/basics/anchorpy-main/tests/client-gen/token/types/account_state.py
new file mode 100644
index 0000000..29e8464
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/types/account_state.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+import typing
+from dataclasses import dataclass
+from anchorpy.borsh_extension import EnumForCodegen
+import borsh_construct as borsh
+
+
+class UninitializedJSON(typing.TypedDict):
+ kind: typing.Literal["Uninitialized"]
+
+
+class InitializedJSON(typing.TypedDict):
+ kind: typing.Literal["Initialized"]
+
+
+class FrozenJSON(typing.TypedDict):
+ kind: typing.Literal["Frozen"]
+
+
+@dataclass
+class Uninitialized:
+ discriminator: typing.ClassVar = 0
+ kind: typing.ClassVar = "Uninitialized"
+
+ @classmethod
+ def to_json(cls) -> UninitializedJSON:
+ return UninitializedJSON(
+ kind="Uninitialized",
+ )
+
+ @classmethod
+ def to_encodable(cls) -> dict:
+ return {
+ "Uninitialized": {},
+ }
+
+
+@dataclass
+class Initialized:
+ discriminator: typing.ClassVar = 1
+ kind: typing.ClassVar = "Initialized"
+
+ @classmethod
+ def to_json(cls) -> InitializedJSON:
+ return InitializedJSON(
+ kind="Initialized",
+ )
+
+ @classmethod
+ def to_encodable(cls) -> dict:
+ return {
+ "Initialized": {},
+ }
+
+
+@dataclass
+class Frozen:
+ discriminator: typing.ClassVar = 2
+ kind: typing.ClassVar = "Frozen"
+
+ @classmethod
+ def to_json(cls) -> FrozenJSON:
+ return FrozenJSON(
+ kind="Frozen",
+ )
+
+ @classmethod
+ def to_encodable(cls) -> dict:
+ return {
+ "Frozen": {},
+ }
+
+
+AccountStateKind = typing.Union[Uninitialized, Initialized, Frozen]
+AccountStateJSON = typing.Union[UninitializedJSON, InitializedJSON, FrozenJSON]
+
+
+def from_decoded(obj: dict) -> AccountStateKind:
+ if not isinstance(obj, dict):
+ raise ValueError("Invalid enum object")
+ if "Uninitialized" in obj:
+ return Uninitialized()
+ if "Initialized" in obj:
+ return Initialized()
+ if "Frozen" in obj:
+ return Frozen()
+ raise ValueError("Invalid enum object")
+
+
+def from_json(obj: AccountStateJSON) -> AccountStateKind:
+ if obj["kind"] == "Uninitialized":
+ return Uninitialized()
+ if obj["kind"] == "Initialized":
+ return Initialized()
+ if obj["kind"] == "Frozen":
+ return Frozen()
+ kind = obj["kind"]
+ raise ValueError(f"Unrecognized enum kind: {kind}")
+
+
+layout = EnumForCodegen(
+ "Uninitialized" / borsh.CStruct(),
+ "Initialized" / borsh.CStruct(),
+ "Frozen" / borsh.CStruct(),
+)
diff --git a/basics/anchorpy-main/tests/client-gen/token/types/authority_type.py b/basics/anchorpy-main/tests/client-gen/token/types/authority_type.py
new file mode 100644
index 0000000..b77138e
--- /dev/null
+++ b/basics/anchorpy-main/tests/client-gen/token/types/authority_type.py
@@ -0,0 +1,134 @@
+from __future__ import annotations
+import typing
+from dataclasses import dataclass
+from anchorpy.borsh_extension import EnumForCodegen
+import borsh_construct as borsh
+
+
+class MintTokensJSON(typing.TypedDict):
+ kind: typing.Literal["MintTokens"]
+
+
+class FreezeAccountJSON(typing.TypedDict):
+ kind: typing.Literal["FreezeAccount"]
+
+
+class AccountOwnerJSON(typing.TypedDict):
+ kind: typing.Literal["AccountOwner"]
+
+
+class CloseAccountJSON(typing.TypedDict):
+ kind: typing.Literal["CloseAccount"]
+
+
+@dataclass
+class MintTokens:
+ discriminator: typing.ClassVar = 0
+ kind: typing.ClassVar = "MintTokens"
+
+ @classmethod
+ def to_json(cls) -> MintTokensJSON:
+ return MintTokensJSON(
+ kind="MintTokens",
+ )
+
+ @classmethod
+ def to_encodable(cls) -> dict:
+ return {
+ "MintTokens": {},
+ }
+
+
+@dataclass
+class FreezeAccount:
+ discriminator: typing.ClassVar = 1
+ kind: typing.ClassVar = "FreezeAccount"
+
+ @classmethod
+ def to_json(cls) -> FreezeAccountJSON:
+ return FreezeAccountJSON(
+ kind="FreezeAccount",
+ )
+
+ @classmethod
+ def to_encodable(cls) -> dict:
+ return {
+ "FreezeAccount": {},
+ }
+
+
+@dataclass
+class AccountOwner:
+ discriminator: typing.ClassVar = 2
+ kind: typing.ClassVar = "AccountOwner"
+
+ @classmethod
+ def to_json(cls) -> AccountOwnerJSON:
+ return AccountOwnerJSON(
+ kind="AccountOwner",
+ )
+
+ @classmethod
+ def to_encodable(cls) -> dict:
+ return {
+ "AccountOwner": {},
+ }
+
+
+@dataclass
+class CloseAccount:
+ discriminator: typing.ClassVar = 3
+ kind: typing.ClassVar = "CloseAccount"
+
+ @classmethod
+ def to_json(cls) -> CloseAccountJSON:
+ return CloseAccountJSON(
+ kind="CloseAccount",
+ )
+
+ @classmethod
+ def to_encodable(cls) -> dict:
+ return {
+ "CloseAccount": {},
+ }
+
+
+AuthorityTypeKind = typing.Union[MintTokens, FreezeAccount, AccountOwner, CloseAccount]
+AuthorityTypeJSON = typing.Union[
+ MintTokensJSON, FreezeAccountJSON, AccountOwnerJSON, CloseAccountJSON
+]
+
+
+def from_decoded(obj: dict) -> AuthorityTypeKind:
+ if not isinstance(obj, dict):
+ raise ValueError("Invalid enum object")
+ if "MintTokens" in obj:
+ return MintTokens()
+ if "FreezeAccount" in obj:
+ return FreezeAccount()
+ if "AccountOwner" in obj:
+ return AccountOwner()
+ if "CloseAccount" in obj:
+ return CloseAccount()
+ raise ValueError("Invalid enum object")
+
+
+def from_json(obj: AuthorityTypeJSON) -> AuthorityTypeKind:
+ if obj["kind"] == "MintTokens":
+ return MintTokens()
+ if obj["kind"] == "FreezeAccount":
+ return FreezeAccount()
+ if obj["kind"] == "AccountOwner":
+ return AccountOwner()
+ if obj["kind"] == "CloseAccount":
+ return CloseAccount()
+ kind = obj["kind"]
+ raise ValueError(f"Unrecognized enum kind: {kind}")
+
+
+layout = EnumForCodegen(
+ "MintTokens" / borsh.CStruct(),
+ "FreezeAccount" / borsh.CStruct(),
+ "AccountOwner" / borsh.CStruct(),
+ "CloseAccount" / borsh.CStruct(),
+)
From d1e9ed7842121c4f06cc638a26c34b4bab618d5a Mon Sep 17 00:00:00 2001
From: Rohit Goyal <66769571+rohit-goyal@users.noreply.github.com>
Date: Thu, 16 Nov 2023 09:35:51 +0530
Subject: [PATCH 18/19] Delete basics/anchorpy-main/tests/client-gen/aq
---
basics/anchorpy-main/tests/client-gen/aq | 1 -
1 file changed, 1 deletion(-)
delete mode 100644 basics/anchorpy-main/tests/client-gen/aq
diff --git a/basics/anchorpy-main/tests/client-gen/aq b/basics/anchorpy-main/tests/client-gen/aq
deleted file mode 100644
index 8b13789..0000000
--- a/basics/anchorpy-main/tests/client-gen/aq
+++ /dev/null
@@ -1 +0,0 @@
-
From 5d67cb64878d8695533a512ad58ae6ca48318aef Mon Sep 17 00:00:00 2001
From: Rohit Goyal <66769571+rohit-goyal@users.noreply.github.com>
Date: Thu, 16 Nov 2023 09:38:56 +0530
Subject: [PATCH 19/19] Add files via upload
---
basics/anchorpy-main/docs/cli/index.md | 80 +++
basics/anchorpy-main/docs/clientgen/index.md | 206 ++++++
basics/anchorpy-main/docs/css/custom.css | 25 +
.../anchorpy-main/docs/css/mkdocstrings.css | 6 +
basics/anchorpy-main/docs/css/termynal.css | 108 +++
.../docs/dynamic_client/api_reference.md | 27 +
.../comparison_with_anchor_ts.md | 36 +
.../docs/dynamic_client/examples.md | 85 +++
.../docs/dynamic_client/index.md | 165 +++++
basics/anchorpy-main/docs/img/anchor.svg | 1 +
basics/anchorpy-main/docs/img/logo.png | Bin 0 -> 502304 bytes
basics/anchorpy-main/docs/index.md | 23 +
basics/anchorpy-main/docs/js/custom.js | 105 +++
basics/anchorpy-main/docs/js/termynal.js | 264 ++++++++
basics/anchorpy-main/docs/testing/index.md | 202 ++++++
.../examples/client-gen/basic_2/__init__.py | 0
.../client-gen/basic_2/accounts/__init__.py | 1 +
.../client-gen/basic_2/accounts/counter.py | 87 +++
.../client-gen/basic_2/errors/__init__.py | 26 +
.../client-gen/basic_2/errors/anchor.py | 590 ++++++++++++++++
.../basic_2/instructions/__init__.py | 2 +
.../client-gen/basic_2/instructions/create.py | 41 ++
.../basic_2/instructions/increment.py | 27 +
.../examples/client-gen/basic_2/program_id.py | 3 +
.../examples/client-gen/tictactoe/__init__.py | 0
.../client-gen/tictactoe/accounts/__init__.py | 1 +
.../client-gen/tictactoe/accounts/game.py | 135 ++++
.../client-gen/tictactoe/errors/__init__.py | 29 +
.../client-gen/tictactoe/errors/anchor.py | 590 ++++++++++++++++
.../client-gen/tictactoe/errors/custom.py | 66 ++
.../tictactoe/instructions/__init__.py | 2 +
.../client-gen/tictactoe/instructions/play.py | 41 ++
.../tictactoe/instructions/setup_game.py | 43 ++
.../client-gen/tictactoe/program_id.py | 3 +
.../client-gen/tictactoe/types/__init__.py | 7 +
.../client-gen/tictactoe/types/game_state.py | 129 ++++
.../client-gen/tictactoe/types/sign.py | 75 +++
.../client-gen/tictactoe/types/tile.py | 31 +
basics/anchorpy-main/overrides/main.html | 5 +
basics/anchorpy-main/src/anchorpy/__init__.py | 52 ++
.../src/anchorpy/borsh_extension.py | 121 ++++
basics/anchorpy-main/src/anchorpy/cli.py | 142 ++++
.../src/anchorpy/clientgen/__init__.py | 0
.../src/anchorpy/clientgen/accounts.py | 303 +++++++++
.../src/anchorpy/clientgen/common.py | 636 ++++++++++++++++++
.../src/anchorpy/clientgen/errors.py | 245 +++++++
.../src/anchorpy/clientgen/genpy_extension.py | 239 +++++++
.../src/anchorpy/clientgen/instructions.py | 363 ++++++++++
.../src/anchorpy/clientgen/program_id.py | 16 +
.../src/anchorpy/clientgen/types.py | 623 +++++++++++++++++
.../src/anchorpy/coder/__init__.py | 1 +
.../src/anchorpy/coder/accounts.py | 73 ++
.../anchorpy-main/src/anchorpy/coder/coder.py | 20 +
.../src/anchorpy/coder/common.py | 125 ++++
.../anchorpy-main/src/anchorpy/coder/event.py | 82 +++
.../anchorpy-main/src/anchorpy/coder/idl.py | 325 +++++++++
.../src/anchorpy/coder/instruction.py | 98 +++
basics/anchorpy-main/src/anchorpy/error.py | 340 ++++++++++
basics/anchorpy-main/src/anchorpy/idl.py | 46 ++
.../src/anchorpy/program/__init__.py | 1 +
.../src/anchorpy/program/common.py | 90 +++
.../src/anchorpy/program/context.py | 69 ++
.../src/anchorpy/program/core.py | 264 ++++++++
.../src/anchorpy/program/event.py | 166 +++++
.../anchorpy/program/namespace/__init__.py | 1 +
.../src/anchorpy/program/namespace/account.py | 231 +++++++
.../anchorpy/program/namespace/instruction.py | 127 ++++
.../src/anchorpy/program/namespace/methods.py | 158 +++++
.../src/anchorpy/program/namespace/rpc.py | 71 ++
.../anchorpy/program/namespace/simulate.py | 94 +++
.../anchorpy/program/namespace/transaction.py | 65 ++
.../src/anchorpy/program/namespace/types.py | 27 +
basics/anchorpy-main/src/anchorpy/provider.py | 219 ++++++
basics/anchorpy-main/src/anchorpy/py.typed | 0
.../src/anchorpy/pytest_plugin.py | 296 ++++++++
basics/anchorpy-main/src/anchorpy/template.py | 31 +
.../src/anchorpy/utils/__init__.py | 4 +
.../anchorpy-main/src/anchorpy/utils/rpc.py | 157 +++++
.../anchorpy-main/src/anchorpy/utils/token.py | 318 +++++++++
.../anchorpy-main/src/anchorpy/workspace.py | 52 ++
80 files changed, 9558 insertions(+)
create mode 100644 basics/anchorpy-main/docs/cli/index.md
create mode 100644 basics/anchorpy-main/docs/clientgen/index.md
create mode 100644 basics/anchorpy-main/docs/css/custom.css
create mode 100644 basics/anchorpy-main/docs/css/mkdocstrings.css
create mode 100644 basics/anchorpy-main/docs/css/termynal.css
create mode 100644 basics/anchorpy-main/docs/dynamic_client/api_reference.md
create mode 100644 basics/anchorpy-main/docs/dynamic_client/comparison_with_anchor_ts.md
create mode 100644 basics/anchorpy-main/docs/dynamic_client/examples.md
create mode 100644 basics/anchorpy-main/docs/dynamic_client/index.md
create mode 100644 basics/anchorpy-main/docs/img/anchor.svg
create mode 100644 basics/anchorpy-main/docs/img/logo.png
create mode 100644 basics/anchorpy-main/docs/index.md
create mode 100644 basics/anchorpy-main/docs/js/custom.js
create mode 100644 basics/anchorpy-main/docs/js/termynal.js
create mode 100644 basics/anchorpy-main/docs/testing/index.md
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/accounts/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/accounts/counter.py
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/errors/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/errors/anchor.py
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/instructions/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/instructions/create.py
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/instructions/increment.py
create mode 100644 basics/anchorpy-main/examples/client-gen/basic_2/program_id.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/accounts/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/accounts/game.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/errors/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/errors/anchor.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/errors/custom.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/instructions/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/instructions/play.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/instructions/setup_game.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/program_id.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/types/__init__.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/types/game_state.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/types/sign.py
create mode 100644 basics/anchorpy-main/examples/client-gen/tictactoe/types/tile.py
create mode 100644 basics/anchorpy-main/overrides/main.html
create mode 100644 basics/anchorpy-main/src/anchorpy/__init__.py
create mode 100644 basics/anchorpy-main/src/anchorpy/borsh_extension.py
create mode 100644 basics/anchorpy-main/src/anchorpy/cli.py
create mode 100644 basics/anchorpy-main/src/anchorpy/clientgen/__init__.py
create mode 100644 basics/anchorpy-main/src/anchorpy/clientgen/accounts.py
create mode 100644 basics/anchorpy-main/src/anchorpy/clientgen/common.py
create mode 100644 basics/anchorpy-main/src/anchorpy/clientgen/errors.py
create mode 100644 basics/anchorpy-main/src/anchorpy/clientgen/genpy_extension.py
create mode 100644 basics/anchorpy-main/src/anchorpy/clientgen/instructions.py
create mode 100644 basics/anchorpy-main/src/anchorpy/clientgen/program_id.py
create mode 100644 basics/anchorpy-main/src/anchorpy/clientgen/types.py
create mode 100644 basics/anchorpy-main/src/anchorpy/coder/__init__.py
create mode 100644 basics/anchorpy-main/src/anchorpy/coder/accounts.py
create mode 100644 basics/anchorpy-main/src/anchorpy/coder/coder.py
create mode 100644 basics/anchorpy-main/src/anchorpy/coder/common.py
create mode 100644 basics/anchorpy-main/src/anchorpy/coder/event.py
create mode 100644 basics/anchorpy-main/src/anchorpy/coder/idl.py
create mode 100644 basics/anchorpy-main/src/anchorpy/coder/instruction.py
create mode 100644 basics/anchorpy-main/src/anchorpy/error.py
create mode 100644 basics/anchorpy-main/src/anchorpy/idl.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/__init__.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/common.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/context.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/core.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/event.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/namespace/__init__.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/namespace/account.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/namespace/instruction.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/namespace/methods.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/namespace/rpc.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/namespace/simulate.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/namespace/transaction.py
create mode 100644 basics/anchorpy-main/src/anchorpy/program/namespace/types.py
create mode 100644 basics/anchorpy-main/src/anchorpy/provider.py
create mode 100644 basics/anchorpy-main/src/anchorpy/py.typed
create mode 100644 basics/anchorpy-main/src/anchorpy/pytest_plugin.py
create mode 100644 basics/anchorpy-main/src/anchorpy/template.py
create mode 100644 basics/anchorpy-main/src/anchorpy/utils/__init__.py
create mode 100644 basics/anchorpy-main/src/anchorpy/utils/rpc.py
create mode 100644 basics/anchorpy-main/src/anchorpy/utils/token.py
create mode 100644 basics/anchorpy-main/src/anchorpy/workspace.py
diff --git a/basics/anchorpy-main/docs/cli/index.md b/basics/anchorpy-main/docs/cli/index.md
new file mode 100644
index 0000000..d32f867
--- /dev/null
+++ b/basics/anchorpy-main/docs/cli/index.md
@@ -0,0 +1,80 @@
+# AnchorPy CLI
+
+AnchorPy comes with a CLI to make your life easier when using Python with Anchor.
+
+
+```console
+$ anchorpy --help
+Usage: anchorpy [OPTIONS] COMMAND [ARGS]...
+
+ AnchorPy CLI.
+
+Options:
+ --install-completion [bash|zsh|fish|powershell|pwsh]
+ Install completion for the specified shell.
+ --show-completion [bash|zsh|fish|powershell|pwsh]
+ Show completion for the specified shell, to
+ copy it or customize the installation.
+ --help Show this message and exit.
+
+Commands:
+ init Create a basic Python test file for an Anchor program.
+ shell Start IPython shell with AnchorPy workspace object initialized.
+```
+
+## Commands
+
+### Init
+
+```console
+$ anchorpy init --help
+Usage: anchorpy init [OPTIONS] PROGRAM_NAME
+
+ Create a basic Python test file for an Anchor program.
+
+ This does not replace `anchor init`, but rather should be run after it.
+
+ The test file will live at `tests/test_$PROGRAM_NAME.py`.
+
+Arguments:
+ PROGRAM_NAME The name of the Anchor program. [required]
+
+Options:
+ --help Show this message and exit.
+```
+
+### Shell
+
+```console
+$ anchorpy shell --help
+Usage: anchorpy shell [OPTIONS]
+
+ Start IPython shell with AnchorPy workspace object initialized.
+
+ Note that you should run `anchor localnet` before `anchorpy shell`.
+
+Options:
+ --help Show this message and exit.
+```
+
+#### Example
+
+
+
+```console
+$ cd anchor/examples/tutorial/basic-0 && anchorpy shell
+Python 3.9.1 (default, Dec 11 2020, 14:32:07)
+Type 'copyright', 'credits' or 'license' for more information
+IPython 7.30.1 -- An enhanced Interactive Python. Type '?' for help.
+
+Hint: type `workspace` to see the Anchor workspace object.
+
+# In [1]:$ await workspace["basic_0"].rpc["initialize"]()
+Out[1]: '2q1Z8BcsSBikMLEFoeFGhUukfsNYLJx7y33rMZ57Eh4gAHJxpJ9oP9b9aFyrizh9wcuiVtAAxvmBifCXdqWeNLor'
+```
+
+
+
+### Client-gen
+
+See [Client Generator](../clientgen)
\ No newline at end of file
diff --git a/basics/anchorpy-main/docs/clientgen/index.md b/basics/anchorpy-main/docs/clientgen/index.md
new file mode 100644
index 0000000..d44f8ce
--- /dev/null
+++ b/basics/anchorpy-main/docs/clientgen/index.md
@@ -0,0 +1,206 @@
+# Client Generator
+
+The `anchorpy client-gen` command generates a Python client based on an Anchor IDL. This client provides functions for
+generating instructions and class definitions for fetching and serializing accounts. The output is very similar
+to the Typescript code produced by [anchor-client-gen](https://github.com/kklas/anchor-client-gen).
+
+## Features
+
+- Fully typed.
+- Supports all Anchor field types.
+- Makes enums and complex types easy to work with.
+- Generates error classes for each error.
+- Provides `to_json` and `from_json` utility functions for types and accounts.
+
+!!! note
+ It is recommended to use the generated client instead of the dynamic client where possible, as it is easier to
+ work with and comes with proper type hints.
+
+## Usage
+
+```console
+$ anchorpy client-gen --help
+Usage: anchorpy client-gen [OPTIONS] IDL OUT
+
+ Generate Python client code from the specified anchor IDL.
+
+Arguments:
+ IDL Anchor IDL file path [required]
+ OUT Output directory. [required]
+
+Options:
+ --program-id TEXT Optional program ID to be included in the code
+ --help Show this message and exit.
+
+```
+
+## Example
+
+
+
+```console
+$ anchorpy client-gen path/to/idl.json ./my_client
+generating package...
+generating program_id.py...
+generating errors.py...
+generating instructions...
+generating types...
+generating accounts...
+```
+
+
+
+This will generate code to `./my_client`:
+
+```
+.
+├── accounts
+│ ├── foo_account.py
+│ └── __init__.py
+├── instructions
+│ ├── some_instruction.py
+│ ├── other_instruction.py
+│ └── __init__.py
+├── types
+│ ├── bar_struct.py
+│ ├── baz_enum.py
+│ └── __init__.py
+├── errors
+│ ├── anchor.py
+│ ├── custom.py
+│ └── __init__.py
+└── program_id.py
+```
+
+## Using the generated client
+
+### Instructions
+
+```python
+from solana.transaction import Transaction
+from solders.keypair import Keypair
+from solders.pubkey import Pubkey
+from anchorpy import Provider
+from my_client.instructions import some_instruction
+
+ # call an instruction
+foo_account = Keypair()
+
+ix = some_instruction({
+ "foo_param": "...",
+ "bar_param": "...",
+ ...
+}, {
+ "foo_account": foo_account.pubkey(), # signer
+ "bar_account": Pubkey("..."),
+ ...
+})
+tx = Transaction().add(ix)
+
+provider = Provider.local()
+
+await provider.send(tx, [payer, foo_account])
+```
+
+### Accounts
+
+```python
+from solders.pubkey import Pubkey
+from my_client.accounts import FooAccount
+
+# fetch an account
+addr = Pubkey("...")
+
+acc = await FooAccount.fetch(connection, addr)
+if acc is None:
+ # the fetch method returns null when the account is uninitialized
+ raise ValueError("account not found")
+
+
+# convert to a JSON object
+obj = acc.to_json()
+print(obj)
+
+# load from JSON
+acc_from_json = FooAccount.from_json(obj)
+```
+
+### Types
+
+```python
+# structs
+
+from my_client.types import BarStruct
+
+bar_struct = BarStruct(
+ some_field="...",
+ other_field="...",
+)
+
+print(bar_struct.to_json())
+```
+
+```python
+# enums
+
+from my_client.types import baz_enum
+
+tuple_enum = baz_enum.SomeTupleKind((True, False, "some value"))
+struct_enum = baz_enum.SomeStructKind({
+ "field1": "...",
+ "field2": "...",
+})
+disc_enum = baz_enum.SomeDiscriminantKind()
+
+print(tuple_enum.toJSON(), struct_enum.toJSON(), disc_enum.toJSON())
+```
+
+```python
+# types are used as arguments in instruction calls (where needed):
+ix = some_instruction({
+ "some_struct_field": bar_struct,
+ "some_enum_field": tuple_enum,
+ # ...
+}, {
+ # accounts
+ # ...
+})
+
+# in case of struct fields, it's also possible to pass them as objects:
+ix = some_instruction({
+ "some_struct_field": {
+ "some_field": "...",
+ "other_field": "...",
+ },
+ # ...,
+}, {
+ # accounts
+ # ...
+})
+```
+
+### Errors
+
+```python
+from solana.rpc.core import RPCException
+from my_client.errors import from_tx_error
+from my_client.errors.custom import SomeCustomError
+
+try:
+ await provider.send(tx, [payer])
+except RPCException as exc:
+ parsed = from_tx_error(exc)
+ raise parsed from exc
+```
+
+## Program ID
+
+The client generator pulls the program ID from:
+
+- the input IDL
+- the `--program-id` flag
+
+If the IDL doesn't contain the program ID then you will need to pass it via the `--program-id` flag.
+
+This program ID is then written into the `program_id.py` file.
+
diff --git a/basics/anchorpy-main/docs/css/custom.css b/basics/anchorpy-main/docs/css/custom.css
new file mode 100644
index 0000000..574fc63
--- /dev/null
+++ b/basics/anchorpy-main/docs/css/custom.css
@@ -0,0 +1,25 @@
+.termynal-comment {
+ color: #4a968f;
+ font-style: italic;
+ display: block;
+}
+
+.termy [data-termynal] {
+ white-space: pre-wrap;
+ font-size: 14px;
+ overflow-wrap: break-word;
+}
+
+a.external-link::after {
+ /* \00A0 is a non-breaking space
+ to make the mark be on the same line as the link
+ */
+ content: "\00A0[↪]";
+}
+
+a.internal-link::after {
+ /* \00A0 is a non-breaking space
+ to make the mark be on the same line as the link
+ */
+ content: "\00A0↪";
+}
\ No newline at end of file
diff --git a/basics/anchorpy-main/docs/css/mkdocstrings.css b/basics/anchorpy-main/docs/css/mkdocstrings.css
new file mode 100644
index 0000000..024fe6e
--- /dev/null
+++ b/basics/anchorpy-main/docs/css/mkdocstrings.css
@@ -0,0 +1,6 @@
+/* Indentation. */
+div.doc-contents:not(.first) {
+ padding-left: 25px;
+ border-left: 4px solid rgba(230, 230, 230);
+ margin-bottom: 80px;
+ }
diff --git a/basics/anchorpy-main/docs/css/termynal.css b/basics/anchorpy-main/docs/css/termynal.css
new file mode 100644
index 0000000..dfe3caa
--- /dev/null
+++ b/basics/anchorpy-main/docs/css/termynal.css
@@ -0,0 +1,108 @@
+/**
+ * termynal.js
+ *
+ * @author Ines Montani
+ * @version 0.0.1
+ * @license MIT
+ */
+
+ :root {
+ --color-bg: #252a33;
+ --color-text: #eee;
+ --color-text-subtle: #a2a2a2;
+}
+
+[data-termynal] {
+ width: 750px;
+ max-width: 100%;
+ background: var(--color-bg);
+ color: var(--color-text);
+ font-size: 18px;
+ /* font-family: 'Fira Mono', Consolas, Menlo, Monaco, 'Courier New', Courier, monospace; */
+ font-family: 'Roboto Mono', 'Fira Mono', Consolas, Menlo, Monaco, 'Courier New', Courier, monospace;
+ border-radius: 4px;
+ padding: 75px 45px 35px;
+ position: relative;
+ -webkit-box-sizing: border-box;
+ box-sizing: border-box;
+}
+
+[data-termynal]:before {
+ content: '';
+ position: absolute;
+ top: 15px;
+ left: 15px;
+ display: inline-block;
+ width: 15px;
+ height: 15px;
+ border-radius: 50%;
+ /* A little hack to display the window buttons in one pseudo element. */
+ background: #d9515d;
+ -webkit-box-shadow: 25px 0 0 #f4c025, 50px 0 0 #3ec930;
+ box-shadow: 25px 0 0 #f4c025, 50px 0 0 #3ec930;
+}
+
+[data-termynal]:after {
+ content: 'bash';
+ position: absolute;
+ color: var(--color-text-subtle);
+ top: 5px;
+ left: 0;
+ width: 100%;
+ text-align: center;
+}
+
+a[data-terminal-control] {
+ text-align: right;
+ display: block;
+ color: #aebbff;
+}
+
+[data-ty] {
+ display: block;
+ line-height: 2;
+}
+
+[data-ty]:before {
+ /* Set up defaults and ensure empty lines are displayed. */
+ content: '';
+ display: inline-block;
+ vertical-align: middle;
+}
+
+[data-ty="input"]:before,
+[data-ty-prompt]:before {
+ margin-right: 0.75em;
+ color: var(--color-text-subtle);
+}
+
+[data-ty="input"]:before {
+ content: '$';
+}
+
+[data-ty][data-ty-prompt]:before {
+ content: attr(data-ty-prompt);
+}
+
+[data-ty-cursor]:after {
+ content: attr(data-ty-cursor);
+ font-family: monospace;
+ margin-left: 0.5em;
+ -webkit-animation: blink 1s infinite;
+ animation: blink 1s infinite;
+}
+
+
+/* Cursor animation */
+
+@-webkit-keyframes blink {
+ 50% {
+ opacity: 0;
+ }
+}
+
+@keyframes blink {
+ 50% {
+ opacity: 0;
+ }
+}
diff --git a/basics/anchorpy-main/docs/dynamic_client/api_reference.md b/basics/anchorpy-main/docs/dynamic_client/api_reference.md
new file mode 100644
index 0000000..261b98d
--- /dev/null
+++ b/basics/anchorpy-main/docs/dynamic_client/api_reference.md
@@ -0,0 +1,27 @@
+# API Reference
+
+
+:::anchorpy.Program
+:::anchorpy.Provider
+:::anchorpy.Context
+:::anchorpy.create_workspace
+:::anchorpy.close_workspace
+:::anchorpy.bankrun_fixture
+:::anchorpy.workspace_fixture
+:::anchorpy.localnet_fixture
+:::anchorpy.Wallet
+:::anchorpy.Coder
+:::anchorpy.InstructionCoder
+:::anchorpy.EventCoder
+:::anchorpy.AccountsCoder
+:::anchorpy.NamedInstruction
+:::anchorpy.IdlProgramAccount
+:::anchorpy.Event
+:::anchorpy.translate_address
+:::anchorpy.validate_accounts
+:::anchorpy.AccountClient
+:::anchorpy.ProgramAccount
+:::anchorpy.EventParser
+:::anchorpy.SimulateResponse
+:::anchorpy.error
+:::anchorpy.utils
diff --git a/basics/anchorpy-main/docs/dynamic_client/comparison_with_anchor_ts.md b/basics/anchorpy-main/docs/dynamic_client/comparison_with_anchor_ts.md
new file mode 100644
index 0000000..db3e220
--- /dev/null
+++ b/basics/anchorpy-main/docs/dynamic_client/comparison_with_anchor_ts.md
@@ -0,0 +1,36 @@
+# Comparison with Typescript
+
+While AnchorPy is quite similar to the Anchor Typescript client,
+there are some differences:
+
+## Dictionaries instead of objects
+
+AnchorPy tends to use dictionaries, so it uses `[key]` in some places where
+`anchor-ts` would use `.key`.
+For example, AnchorPy uses `workspace["basic_1"]` instead of `workspace.basic_1`,
+and `program.rpc["initialize"]()` instead of `program.rpc.initialize()`
+
+## Explicit `Context` object
+
+AnchorPy uses a `Context` dataclass and has a `ctx` keyword argument when
+calling `.rpc` functions, whereas Typescript is a bit less structured.
+
+We call `program.rpc["my_func"](ctx=Context({"my_account": my_account}))`
+instead of `program.rpc["my_func"]({"my_account": my_account})`
+
+## snake_case 🐍 instead of camelCase 🐪
+
+AnchorPy uses more `snake_case` to match Rust and be Pythonic.
+Specifically, the following names are snake-case in AnchorPy:
+
+- Workspaces: `workspace["puppet_master"]` instead of `workspace["puppetMaster"]`
+- Instructions: `program.rpc["my_func"]` (and `program.instruction["my_func"]`) instead of
+`program.rpc["myFunc"]`.
+- Accounts in the `ctx` arg: `{"my_account": my_account}` instead of `{"myAccount": my_account}`
+- Fields in user-defined types: `program.type["TransactionAccount"](is_writable=True)` instead of
+`program.type["TransactionAccount"](isWritable=True)`
+
+## `program.type` namespace for user-defined types
+
+The AnchorPy `Program` object has a `.type` attribute for instantiating user-defined types. This is not present in
+the Typescript client. See the [examples](examples.md) for more on this.
diff --git a/basics/anchorpy-main/docs/dynamic_client/examples.md b/basics/anchorpy-main/docs/dynamic_client/examples.md
new file mode 100644
index 0000000..b91b806
--- /dev/null
+++ b/basics/anchorpy-main/docs/dynamic_client/examples.md
@@ -0,0 +1,85 @@
+# Examples
+
+Here are some of the other things you can do with AnchorPy:
+
+## Loading a Program from an on-chain IDL
+
+If a program's IDL is stored on-chain, you can use it
+to initialize a program object using `Program.at`.
+
+````python
+import asyncio
+from solana.rpc.async_api import AsyncClient
+from solders.pubkey import Pubkey
+from anchorpy import Program, Provider, Wallet
+
+
+async def main():
+ client = AsyncClient("https://api.mainnet-beta.solana.com/")
+ provider = Provider(client, Wallet.local())
+ # load the Serum Swap Program (not the Serum dex itself).
+ program_id = Pubkey.from_string("22Y43yTVxuUkoRKdm9thyRhQ3SdgQS7c7kB6UNCiaczD")
+ program = await Program.at(
+ program_id, provider
+ )
+ print(program.idl.name) # swap
+ await program.close()
+
+
+asyncio.run(main())
+
+
+````
+
+## Instantiating user-defined types with `program.type`
+
+### Enums
+
+Suppose we have an instruction that expects an Enum called `Side`,
+with variants `Buy` and `Sell`. The `Program` object has a `.type`
+namespace to make it easy to use this enum:
+
+````python
+await program.rpc["my_func"](program.type["Side"].Buy())
+
+````
+See [test_token_proxy.py](https://github.com/kevinheavey/anchorpy/blob/main/tests/test_token_proxy.py)
+for a more concrete example.
+
+### Structs
+
+`.type` also allows us to build structs defined in the IDL.
+See this snippet from [test_multisig.py](https://github.com/kevinheavey/anchorpy/blob/main/tests/test_multisig.py):
+
+````python
+program.type["TransactionAccount"](
+ pubkey=multisig.pubkey(),
+ is_writable=True,
+ is_signer=False,
+)
+
+````
+
+## Bulk-fetching data with `.fetch_multiple`
+
+You can use `.fetch_multiple` to get deserialized account data
+for many accounts at once. Look at this example from `test_misc.py`:
+
+````python
+n_accounts = 200
+pubkeys = [initialized_keypair.pubkey()] * n_accounts # noqa: WPS435
+data_accounts = await program.account["Data"].fetch_multiple(
+ pubkeys, batch_size=2
+)
+
+````
+
+The above example fetches data for the same pubkey 200 times which is
+not very interesting, but it could just as easily be fetching 200
+different accounts. The `.fetch_multiple` method uses async batch RPC requests
+and `getMultipleAccounts` so it's quite efficient.
+
+!!! warning
+ Be mindful of your RPC provider when fetching data, and plan out how
+ many requests you'll end up sending to the RPC node. You can reliably
+ fetch around 300 public keys in one HTTP request.
diff --git a/basics/anchorpy-main/docs/dynamic_client/index.md b/basics/anchorpy-main/docs/dynamic_client/index.md
new file mode 100644
index 0000000..517022a
--- /dev/null
+++ b/basics/anchorpy-main/docs/dynamic_client/index.md
@@ -0,0 +1,165 @@
+# Tutorial
+
+
+!!! note
+ It is recommended to use the generated client instead of the dynamic client where possible, as it is easier to
+ work with and comes with proper type hints.
+
+This tutorial takes the JS snippets from the official Anchor tutorial
+and shows how to achieve the same thing using AnchorPy.
+
+## [A Minimal Example](https://project-serum.github.io/anchor/tutorials/tutorial-0.html)
+This section covers the `basic-0` tutorial:
+### [Generating a Client](https://project-serum.github.io/anchor/tutorials/tutorial-0.html#generating-a-client)
+Here is how we generate a client from an IDL and use it to interact with a smart contract.
+
+
+=== "Python"
+ ````python
+ from pathlib import Path
+ import asyncio
+ import json
+ from solders.pubkey import Pubkey
+ from anchorpy import Idl, Program
+
+ async def main():
+ # Read the generated IDL.
+ with Path("target/idl/basic_0.json").open() as f:
+ raw_idl = f.read()
+ idl = Idl.from_json(raw_idl)
+ # Address of the deployed program.
+ program_id = Pubkey.from_string("")
+ # Generate the program client from IDL.
+ async with Program(idl, program_id) as program:
+ # Execute the RPC.
+ await program.rpc["initialize"]()
+ # If we don't use the context manager, we need to
+ # close the underlying http client, otherwise we get warnings.
+ # await program.close()
+
+ asyncio.run(main())
+
+ ````
+
+=== "JS"
+ ````javascript
+ // Read the generated IDL.
+ const idl = JSON.parse(require('fs').readFileSync('./target/idl/basic_0.json', 'utf8'));
+
+ // Address of the deployed program.
+ const programId = new anchor.web3.Pubkey('');
+
+ // Generate the program client from IDL.
+ const program = new anchor.Program(idl, programId);
+
+ // Execute the RPC.
+ await program.rpc.initialize();
+
+ ````
+
+Note the differences between Python and JS here:
+
+- We call `program.rpc["initialize"]()` instead of `program.rpc.initialize()`
+- We call `program.close()` to close the HTTP connection.
+
+### [Workspaces](https://project-serum.github.io/anchor/tutorials/tutorial-0.html#workspaces)
+
+Here is how workspaces look in AnchorPy:
+
+
+=== "Python"
+ ````python
+ import asyncio
+ from anchorpy import create_workspace, close_workspace
+
+ async def main():
+ # Read the deployed program from the workspace.
+ workspace = create_workspace()
+ program = workspace["basic_0"]
+ # Execute the RPC.
+ await program.rpc["initialize"]()
+ # Close all HTTP clients in the workspace, otherwise we get warnings.
+ await close_workspace(workspace)
+
+ asyncio.run(main())
+
+ ````
+
+=== "JS"
+ ````javascript
+ // Read the deployed program from the workspace.
+ const program = anchor.workspace.Basic0;
+
+ // Execute the RPC.
+ await program.rpc.initialize();
+
+ ````
+
+Note the differences between Python and JS:
+
+- Workspace instantiation is explicit: we have to call the `create_workspace` function.
+ - Note however that AnchorPy provides the `workspace_fixture` factory for convenience.
+ See the [testing](../testing/index.md) section for more.
+- We have a `close_workspace` function that calls `close_program` on all the programs
+in the workspace.
+- The workspace is called `basic_0` instead of `Basic0`. This is because AnchorPy uses snake case 🐍
+!!! Note
+ AnchorPy uses the same case convention as Rust, so names should look just like they do in `lib.rs`.
+ If you're unsure of a name, check `program.idl`: it shows how AnchorPy sees the IDL after parsing
+ it and converting some cases.
+
+## [Arguments and Accounts](https://project-serum.github.io/anchor/tutorials/tutorial-1.html)
+### [Creating and Initializing Accounts](https://project-serum.github.io/anchor/tutorials/tutorial-1.html#creating-and-initializing-accounts)
+
+Here is how we call an RPC function with arguments.
+As in the main Anchor tutorial, we will use `anchor/tutorial/examples/basic-1`:
+
+=== "Python"
+ ````python
+ import asyncio
+ from solders.keypair import Keypair
+ from solders.system_program import ID as SYS_PROGRAM_ID
+ from anchorpy import create_workspace, close_workspace, Context
+
+ async def main():
+ # Read the deployed program from the workspace.
+ workspace = create_workspace()
+ # The program to execute.
+ program = workspace["basic_1"]
+ # The Account to create.
+ my_account = Keypair()
+ # Execute the RPC.
+ accounts = {
+ "my_account": my_account.pubkey(),
+ "user": program.provider.wallet.public_key,
+ "system_program": SYS_PROGRAM_ID
+ }
+ await program.rpc["initialize"](1234, ctx=Context(accounts=accounts, signers=[my_account]))
+ # Close all HTTP clients in the workspace, otherwise we get warnings.
+ await close_workspace(workspace)
+
+ asyncio.run(main())
+
+ ````
+
+=== "JS"
+ ````javascript
+ // The program to execute.
+ const program = anchor.workspace.Basic1;
+
+ // The Account to create.
+ const myAccount = anchor.web3.Keypair();
+
+ // Create the new account and initialize it with the program.
+ await program.rpc.initialize(new anchor.BN(1234), {
+ accounts: {
+ myAccount: myAccount.Pubkey,
+ user: provider.wallet.Pubkey,
+ systemProgram: SystemProgram.programId,
+ },
+ signers: [myAccount],
+ });
+
+ ````
+
+Note how AnchorPy uses an explicit `Context` object in contrast to TS/JS.
diff --git a/basics/anchorpy-main/docs/img/anchor.svg b/basics/anchorpy-main/docs/img/anchor.svg
new file mode 100644
index 0000000..aa184c5
--- /dev/null
+++ b/basics/anchorpy-main/docs/img/anchor.svg
@@ -0,0 +1 @@
+
z#OGC`P%qh|prlFHvo(n76Z=}Xp4ED?Ce2b;Ba;n=mlk91ieFi^c4%q9sbJaoK}JRX
zK9K{{Cpt!jgRA>|ac9JJ>%f02KgJw+F!}edYV7#GA4~Or7Xi`me;48ZF2YJt`2RyB
zFs_#(ZpKN%E=PZv?`^XcZ;&!?(4|Y4lC%XvRO0IgRCy09kGsi|f91WGJFTgysjJK8
zr&#gj%d=W@9>zUFLUiN|Do+P|gvgm~MBOvy{?cpLY$YC|Qra`_BqJ*>KK+X-S|wgI
z?Cb2>=!#yuoYq+dIVs{|^DkraIVKvWO8z(-A-C+mZ`sFOO!qY9I&C@xC)VO?(
zsZcI_pBNhl*Pn`tioF5?0(U%__oxQ3|{e!>yfX%~^By9^4
zDI+g$!B3*y+|p9o{W}R4XQ9z(?vHosYuRk
z+XnjkotCDWW=13;IEzV8oq!|{NRz5xM%hJ%$fF}$H=
zW8mb;lVy(cPoF*=k1Txi<{G~J;K75vy}dorDX(6=!XqRnhab9bieI<4x94HJ<|&KE
z)e50>+4e9i@o*)ci*LU7_nRXMd4qQC+I98n)jY@1_AHx@@t(4U`FWv%)jf$1lz2ov
z*o$&@m*(a95Ff>^mnjeA$Qz)P|L4nI
zy?0j4x%QTNdU}E^8*}T|$Zd-%f8~uBG
z?I(o`Ci~<33un81ac5zwyqx}J7vG!{d`yJ7YK^^C%`DRhR$wJoKaGA(OG}HEb{zSU
zX(?g#{k2syaa%D5kS(1Y2MF9yT)o-1^v91M57`gZVUye1+8P@j`fFnA6V=0iuGT(#
zR{YYZ2ag{=o}1{CIC!w3vC+`EHzfINipABd`}XWvpG$|k6Iy{N_mRjpHa0psI`}7d
zz}D^Cw{P7lN$RgzURv*brqA71_bx+{)rssDuR
zpMdk}rUlMNJ@}bvb2s2qJnj=)dgF?PmDSLA8CS>K%N4%Dh2QJzgOqsQHos~a;!CrY
z)YsRSS>{>TZk^qgnm00^X|!-K@i$iIiTTPcV2Mp9epL!%!DEklE1o!kM6QmMmXMTu
zqRM+)t>@y)v@{zlD=TYjp?&)by6^ABr{uO+=cVN5%k&H3E<}h$7TJ`MmBl6NHrrnt
zhZW9q7?yIIwLNj-M9pbtrR&!xaBGdJ270GY*P;@T2I?{`o6hR!tRuF*Sd0=m#ujYb
zw@bTD56#NY6}Zk=cN8u)=ok$T4sOWx-BB5K!0f}_O^)r(W=IDE1B2_=ucMBNv27w2
z;>HyUY%C5AtnQnbbCcnev;Y0AV5WUxw#PqO)?KQfpZ8f~V`JWE;Q~|i>_=o)T&?-F
zYuB)jQh?SslBx;RSsZLP)>%@<<+=E#jB~KRe=8fC3J)W;hWPcsz`*SaDf8#*$hqDZb=WmGFAq!E($b4S`DcJcyVHlrY5ilqEc@ms6Xo3NPf1ipN@vB!#=d+hz<8|+F>=HA
z17&4?K2l3WS%`A}6-L}odx2|5p*wQ2pFiO(Le0GPnXt#WuS6TE{?+;PTf}b~-(Lxf
zYnRiTNm7xOroQ*@|7dBExcVc*ey}l!PyL~v-)=^qasLmy8R@){&Pb*3r%zK+I;!1A
zuIm^&Up{{Pc#Q$^EY=is&zl+*71fsKSTy~^vd4d;oNZ_EKz$;5T#bRMaF=a%Z0v>M
zADMU;@`6}@|9-|UK1TgS0RZZD&c+ph!BIfJQrjVXFM2-LG@S$vM&dI-K|Y`3x`H)Uo!Z-AdeR6hoHtJSV(txAqjH6A_()8|=kEso)@wGpViLc!uGUp~6qB1oz
z<8NeHWZ9HDJw1&|kKKx?@4OZK_%RVFCAZdK<$5_BTi;kTyquq(kBK8VXmVEGf2sn0#`>FPW5_87CL{CoB!rKK4ay3PG=NJirr+gtQ!@0KlF
zJujVs!{VwHh6#FTKHaOoj3fB-mP>c*-o5xk%9m@HuiScqlZ?mjZ%IT!%IjDfK}A9LsW~q4=2%?q-n9HbgGS_eR1);T
z+eF62tn9MBs{i5X?@dL^Q^fwtdCGG7uZvvGq$bHO1W0titSS>5RmS1y*3A@6lS_jf
zza>hPim@o3pz^}PLLi|_We+(H*_rfJMdDjji1xjKH}~${yIc02)pu;OCwfunKE1PA
zT1=$Pcw#R~e0CllKxz3EX67*&$HgIO+gTHPG%hYqp0&h86JRq*-Tn7tJ?ryX)@|LT
zzLXp845YN@F`;FY!
z=DR7e*lFmWUM_oe$=_AXD`kR6uhrvNSc*>Q(LTPWK(
zswx{Thm>7SFEjR$Nu6EV!OFyhC$s|D9b|}h;Osny^&HKgs4^l?8AZ!^dQf&$pD`c?
z-%RyH%monFb7>0klo=Oy361)MKj)@gnuLc|;@f>o4N+JF0s@ef^d4ik2bE%m{D_7>y$kX7C$Yw<+Z@I;7H6
zE9u+!@83H+JF|+Gh7+SbT*%8y=(zHZC1RN_Q@;n%lM=$MbC>4_PpYVJ2Ppk(p^oKe
zuHcgvgWY7gd`qW?TO3hgddmFeCToroIU_}zkcr|wGdamF=aHY1GCYru8hTp+u5p_v
zj-3W}fy9H7A64`MgUk%K%tVg5nN>XAhf0g3AjjtCFK#fJeNU8_i>3EbD{Up&De*V@
zgmU+uq2(rwKF9R*TF8sh)z(@S1T-gb^`C4Mtwu@Ww@7uR27q$F`mG>2H?a9OHW<8jx_CFRO6j+^=xCh34wib8omQq13*unyAK48t;00
z_l(be{`?th^{X=6bM^xlrxc05pT9F@BRxHrq^+^J`HSS_!RZzo@=rdwfp%AXt1<DA$pk>1l@zhgBU0Nb^8@Z_W*kb$ys=y_i4
zh!}qN?%gr&&7{q?`$2L+qioy<^}t#Xni3su*HL``LBZ(mFhUm8GLns^_fo*><;}Fa
zl83671^d}M1Cx`I=Hle$;{ahT2kPSGv+!5Pv?yPw)jT#v09G&-#88~StV?I{&61Lm
zn7A7!h1luP^^8#bik1h9JZ9P)QB$#`p0;ho%4&;?ivC%|1CD=W;!}$-x3Tdr>p|#w
zA(&A&4V}8Y&IvX)H#_4OtD_D}|LvZnsZj9hb{PXOed(bQxlF%#R_mrI1y9&;0upPvJE>1A0jwa*kfPWGQ(
z*MH$Dnn}@=UeQ!|(Ofvup3oO1+3ARSZ#=)UJMsW0^oJ*F$n!?zz5NWv&uF|q=or{H
z=oJ15A<+4mGi!)v6mh304++62ZNn{Dk3nMK#*UdniY7P~D6qS;4S)3go^&~Hpn~1X0
zp+Pr*A5q$$sx;C5ZtUs){^k;au!+ujwdEc5ocO+%1qJRX3ivG+-<0#|39+#|`?>Mg
z2TCca5o8F7C0^5LzAlv0W47yqH$65=b=B_OyNO4OULJ^UcNt8ns>g#dQ!t^iU4?1-
ziHGcSzjcao@ijnI_?q&cxr3<--x6h~T8frhpe#@VMU^!*kI4OxZ<~j9`OExCv2nM=
zc7mMC_fZ9XEp%V#9-jq)1~nkR&dK?^5G6$I7uka*2lB}m?e@pDW1;*yw@rq1Z-bX+Ur0FtNuiv(1!QI?|Ij6|BmYE;Wid?gw?VvHJ3brIo?qu(Tq~h>or*E1W;}o~YvsBYDEu;omP_y;`jCmYr-H^^jnuJ*18s
zvmKxa>byZFqH|*(=xtiF$Kyi{*|u$4FSYK8CX|~T6cQrn3&Cgs(92bQB>{!D6w1NxWgI4vvm9Gc%AtgbZ@UC_#}_P6-NLZ-9&x1Z->e
zHH7y7NvfaSm=?-bxryCiV@j=gMrtZRsQu;3mscXHa
zp@}6TeLKj@H8mPFhp5OqS$sKU-Lliu)8D?|9f_D-TMxs?Mt1v={+XGJ5=K}k&yWz
z5Z|T-n~0KRiDE`T5rUtIj;j&{WPR7v#(x8vd|MYjdAzgT8{*!(R>D
zQ`i^fddnKi`=pW4=i_#p{Bb`Ux1M!!v+|CPj(98^;ppl_%_OjFWbda(Q1k6Q8LaQ?lViB>*OR|r>&5NtOB7G2tJvqZ(8LhZ*z0!Lp=sUEi5c3
zRPYHkC4P2@K*PXRen(uf7LIvg-P_{<=YSfS>v$`a2HfmOp%lbrA|PkjFOi}
z_e~Z*7nhRCwdp7%kIOBW1*yw!BS8u&=INyLKd;9G|M&*}!nIh!B{TOkhyup{%jZKp
zvH03MIM8j{lwwpQOUah?m6XJ!-4~()=x$t}a0<0Xl~Sy!Smgyme&jjY2!$rUe3?7^
zt_2z(2LZf_sVTY*e}ujepqE;NAnV_s3z4P+w8cj!`rXW;L+S
z4)Rim9F`Uk0Fj_C0NJQH>R;C
zBV)alpF=85O1c8g0KW_-uPP8in`_Say~xuO$m_k=hBTBss67c94zX!KAvmH;G2w&>{B*41h1>$ld|_vl@1*A)n1gHGr;qL1nT
ztU{1ff-5q41rb;!^sHzY1c=2E$D+K;6_24mqb4{CGWvW49|pYy!kIuSXI*Up=ej=h
z{S88~wzf8AkT><5;50O@>L>emvH205ZDpaDDGQ~q8yOi%bV5L=#+H`tqzz-%fTp;r
z!zI$tPvhe+PyKEv8sA=o*@GQcu&SyGADWAH1TN_B_7gab2UvxG0Sqz}47oc40q3_}
zLKYGR`kqkP-SWLGzK0iv(tVCSgQkxr{^G@p%*-i}g!x{h(8j2
zDBeO3f$6}}Ky`s}b8~YcqocYY<)GRD^z05Q$6qiJ-A4L#C#brw?9(Sg=>Ua+9s`wS
zEg{J;@K6?`6dGwZ)`QT#(h8<^fjFhsWt&4<2REhTl5PF=EyK9v7DPi74lE8xyIt+G
zNYE5u`R@y6zU)m~%py;Bs71+yA!#U1FMu~axR={+t!P@J@b6Hf
zAPe82fyC(LP{1}0X$OKJ>fJcGo5go(YARCJ-384B!;2oS2gkU9;tU{_jI`x>-@Q9D
zDYq-M!i$*Ph#_?)ip&wj^?sDSdo-pFhgZ_k(>sz#Ch5&k
zrLY!Q5en@+qr>+A3DpPw2;
zYwD2UXs@e#i(!@qKM6U5NTKt-o}-V=f9G(^3EC^iIaeDTvDXZ3iS0FveD{1jA$&-n=uP=onV>4V(aSaYH1z7
zhW+~W3;TkWhJPAc^4$YB>F6LxAI1w9V^Q*5Ly{68Gdy9ig}Bd$cP#$eAe{dQn6>J^
zTLG1(U?|u~m6Ioh^M>9cco7QANlHALC~Zc>wK9x^l<@ugxz{B(PbSu5fQ5n71{Oi{
zD_8aqa}{urzaEZJg7+c{KKX4YIH-fYJ???}6}Y35Q}(M@R$cGCkp1L2?iq8jT!_tx
zAJ7f}6@(=)A-+2@twSlX9#8xNCEdy@Lc+$7QV7LzTcRtTkP
zkAiK@6bJ)HqDR-y2?~xKs2iB95H50Sz6^Qn-B3|#719S}WdWF*G@RK~g)k(MNVc{j
zP^$u^HX|9Z^tH8bP`MB^lsFeUL@6zK0o8rc9`ggE9y56@SvJ)sqKH!_C81Evn}DOh
zNcQTaE{0XJu(IlCYkx&m1R}$uT*V}4Xo#JS?P(RO-N&ABR5{{~Fd=jRCNlm)sf+oT
zKNE;^d&lf2g31wTcm0MB)QY`fszPXP&_2MJBjo{31V1va~-E7X2QVR)EIOtDk`pBw@xQj|Gb{w
zc3Q9HK}%@2mX?-fMhyOCEkAzznOmH6b5jK2$IJ*jK@1wJBDRq*dHbvPIh8@v{LwT_PcT&6_>&@!-zM{UKk+J5{l0)2XFG~B
z*gLSgo2%FT9vsw3(Vb$+%J%-yg%F2K
zwIaLIZ`{Z%YS(?Q^kS@r`P`pg1PZ3+6!>)VJtf6s@d*GIki}=wlu@3ss^u4qjduhn
z-BF0eDDbXAY_#jBJ3sS%#W>8CaWz}L1EEDwu(i7)WuRZ7)<8$WD2&3ivUw=1ft4q^
znts!!!$c%w#s36bS=84L}O2w@UE4F*!e&36xF6|>HUWF2f*
zUT!X^7O=4|W#DBik5)y%{C@xCehl)T+%40)Im3-=N=H`+#75wIJzZUokqh$@nHd=v
zu3n%F{qwT2vWx?mR0KjS%+1dgx;fYE#ImwRQyRdn{K>kLgbv`0uhkaVLfRlQ2Q;CT
zsOI&d3%wSzfx;OxWc-KeND|J+K@&gOe0NAVhBf?9&(0`TWfoH3As5
zx(^w@z+%KtaHP+~j*U%oy7b3#Eq1QMqOrJi7GQG$Q>8tZ-B1VdXO}Pc>g8v@d*^_=
zgc_Lo>J>XD=g81d#98tNHVzJ`GFh#5CsFgD9#iTK>q-|)fps8K@>(}}xr4j_W$aY)
zrB}tfMMXvHuvtw_P2awKtE*%5Q|#zQCYK_T5Q>02z&ij{7zsaBodOre&=r$+LSl~{g51j;L1QcSATPKu?5jnzc-}$%Cu}9CJ
z|4cDrr}eV1w6w|Yx{E0Rz?xc6q-=QQLr)**K?l%6R*Kle8nK+6sFj@tvt9I_P6RW8
zkfK+!(>4~PCLV-2H=Y|rKR-VofeSEz3qJ#rqvt<=j=zD70kf(!JrD+9j&$%X>jAe1
zAZ7Fc_8sTDwQh;&X*U}iTVt9LS;uoqhfukA7@Y@MF#;w@Exq3$49vF+TFVTErL;`j
zvSB#*ogTe3)F(%ti#dvj6?&L8H_U|^lhM%DwnXT6OOy5T-tY_fDWaaB72{FOzCJmP
zU^sJTi=QI0YgfSM*^T61O5|T^qcKHQZ2C_PX+hJg9rI@x39f9huOmO
zBI5EiHa13vKaJ=TdVqS&7v*#jyAr+llMmLErAA>oF9mcQiB{XA2qfMh=WZW9)SbEk
z(gn@c1l)$~|LNizU{pfzCQ9Op(_;1z$|i=4!~hf2nY5w4*3*z12nD$XKMy{uT>V=^
zLuI(c=-Ub*%d1xnGR$iMmBYisp-Bi^D~g7(Z`}%9Bk2TH;PyIy*dv;o4^c+NL2~;!
z6uVD?!n*hFH7f6$z|LN=wk~{>rH}C_!ZA$s*IZvTF=h`Y>pjoy_4iU%W#OVANh?dX>Ai(!C
zo;k%{Yfc*PE=40d58gnjB%>=mTP_*K8aO3J`}<$lXgLAr63I`@*v?3Fz5ge5V91Q^1E8vHK~eHvnVW~M!Q
zJ;0KeoDjKDA+~1LeF58L;~^5DBzXR<2|N^h>QQi;c++wGfZYcTZ`Du)2}%K$8N$#q
zNC-$pEF>I-_Dp9@qosvfY;Qk>c8sErOafE{iOR9AB=sKjtwR)0!9z1+F(gCrngY0qseDl7nRz{!vC9WSBhE@pWS%Fuf
zbOtE>glB|(fr=M%QS@S1=xM1uSYirz>Nu+BCL6kE)5la&LDgmAjF
zFte`hJu@5u1iJ-}5I*<16Exa|XlN@m5~UKJtlg~hWGgU_X!2s8P3}Mf;Xok9hbVLK
zN!6SVDy~$jNrdh-l7vnv?M6P3;8&cBAhT0|zt;V)jG!*U`+)hS@-vpeQh7K%%o=e-43zF}`P?qeows$6%Jn
zaFfSX4BUZL0`A%Pk_l}9-cS4$I4f)iQ?d-NR~{U9$_Jw(k;M8le0m|(qlXZE`$Ly4
zKXdMw1X28*4CuL%1Ze_JN
zTPD~3;|Ck97mTle=GR?D=_@P#dFrFvd{`
zaXms1a17V??_24-LBUZswB4V~=N*ud$@e5LqnrvX`b&(g)ND7YwXo
za4{Y6^z^JbU1EOqY61QoENUZ!3jNeF73Esl**V8+`8|*`fqMwEE;>6vDeBQKNyVVMIy0uN1Sm#By56>Qzmun=XJ
zT-_d7CUNH1!s=>eySL(cK?zrLg}+%d>*m(Nkvz?Piqh!_V
zQ6A>?^D1(EbFw{-PN+4ws5flvKw_ZST)FDx}7b>uSLEB<){6e(;GKB-R_
z!Mq0Kdl3>Frq^{GmFnjN&m!i|o;`c}(dI5YUaK*rdceNbJC#+&g#P1Xr+nhdN=j{3jIR1*z{3mw#D027T)|ojQpI
z3jhIU%)8*KRWK%mYd
z6LRg$ad9@#t(3FjAt76sn2tJPCWY&Uj{-3-!Br1y)I893hs)r;xLPI0$5b%0YYQ|m
zsmomJi*)4W<$YLfFNf428XT-qQkYw>o<}e6y?5_(RTZ34dg#WN{13ldabS5>_c2k+
zJLX=w!=wD>T*Q+n*{GWl5$stlF#0Mw^1A>XhgR$kt=K|){M@dsn6M#Mq2l9!iPQK7v{$adK8*Ts}U1tyQDA~7JqIH~@(_Efowni?^$fXPC<
z&^xNc`1|lQI@3@`QHMolU1U|3w!j%UiJl$z#Sf~gs<8L^m&HkcBYlLfDbqfCm((6GsztLy&
zLG=S-Y<}MKTn~MH^80q6Ty6tifn0`G6a0SVf
zFF+~vp@W?JJjuWSd?ijIN?0UJ6)J9s3cm0dcX@TS(OZ-9TWdCa8dbY-gn@&j01ikn
zvpaY05IX*$>zF=yk7#&Y7Gtxtu%Kg?jM3l+CgF9(ehcr}qpYIxdvsLJ?&s(4-=7F8
z)OEuh;^X7Pzj9)0$GJ`$LO#QC4rl8Nr8h5DdoHKv`Q%e#B`Qa5YSxdN9=
z4Ssgdnx1h6>hVTB8^Y7s?j+02OpD1P%ziqcVj3C@oSbTo+_NmIyjrmu1kZzWkAQRF
zwih#Xk1qW5vib4uYWO+9Cx(PjMLz^
zy|i*`)Upx(qO=ME!>Lo1X3_5Al9GthBg|X2OobLL#^>kja|h_V!<#V{>DUeqe!|gF
z!mrsa@!7NPE^n^o<(Z=Br%weKXl%#aZfNl{BUp9cTs-dTns+ui^6cRP!!(S`;0RZV
z2mV*P;MLmN3Wkx_23eU=^zh-Ja`rh^Z9)r~0*?9Mh$y<;cVnhRH0kAga*|79&
za_>Zyag#L?3NN-)am~X>f@r;r(OE3h{t4A6+NGZ?mJQociX=|>!fiPzi{qOuOx+O-OuCt9qt^aLLV1~Pgn>|~(n
ze@JOFRJObR2BWbHRN}=y6~b`s-@UsmAReBgEkF#S>!X)5o;|x&deKjAWZY@UVF8S$
z9k~O0Jhw^VMWpVbLpe}FKq8IOO;5qy`>twTCT<5*adMJWU}z(<6;n+G(>n{BP#7Sa
z{3I@uK%T_ctGqviA&2S*2;My~5G%8D-%mSdH@AG1_-E2k!*Lb+#Sml)<#M1G26ik^
zc!_b0v=Y^NdU~U5+b)}Y&b&hne*Bmv_w8w4p7QSQZeZ2Jn7^W&CrHz2_*eH4=#&ef8RNh$+qNk?
zvU`39GKcr6K>vA01_^tyfB*jAW6uIAdM$9`BDsM#$mf6ga4Yg}xEWxLVe*05FR!2=
z5|!jubsu@iOzv-Qwaa|YRTO>!11V4yIkiZsEvvlG9N78*93Q|*4ns`92c+otBV2(r
zw-{)svA^i5GBT~!Sw^lW=zL3Q<8LzbAYYUNQ7&+4d7Qxs19*@jl}Ji%9h!Pq*5h;U
z-n|D8RMpfHq={1**hREkH`&yB2F4
zOaZ~w(z{c75p^7*GN?;oN{Zi)J02K>T$>&`pR2WUQ>`@13M=tef2-MQWN;8h>bEV!
zB(wE209}1>J;J%$JVYKH8HQR0Nw1p4*DKYS8O^f#@JuUY`>3!mpSvDx82p8Wg%OT=
z;&(z+(qu;*@{SHo8H
z3Dub}=bbn)K&Nm(Je*_m=F++8sOG37zP|g{}tH+bzSU>CH`Tv5eoq+@Wy7n4W+B7}0*VtE=nL&SFS^xM-9m3F{HA1TT;>9O5{d++fJzeE2XF)qO~GXc24HtZAal
zb(D%!j3W$I3p1lOSFY?2Q!Q~7LUYwe9ihjZ4J1J+UNho|TqXXM&oM?IAtt5|#vQn%Lpnw~Zy6@+bVoF2L*$NSXWZkbE7_1Txq6AEDm~9)Y#FIN6=Tfk|VqZj0JGgbD
zybC`Sro|gJB)@p^J^NY@EU@PVS=xMdXpGG*K6vl|U3u;8{W3CEqG5!%FE-hep_@`-
z3}f#W8ftbrGYj7_r+oZ9Kr(RWpz>o^6^h>IrdVW3LG|3f|8%TI4F{#dQgyogLnf1v
zGR}7Jhe3sjm!`S;Y5P3XR-6`c1@mm;_&iLK5;n-41Z0JDKS;{$Dk5ncdZM=4`}t!9Op6
zyLrt3iGWL(N#*PFNk}+idI-HO`1!L6sC>w@ezld29NYK$Z?q|Z`GfNi?)W6FM1`dL
z;gYh^C{+-g;b|;~G!d)e)W(EpAv}(RCWR_6Kw3NSxEtkh)P2;I@L<6CA=1lfeS?6u
ze4!Qfb#)&vUc))NHlG(_%M-~B7S1w;rltuJC!wW>sZPTfFCD3NziuwP+~ny2GquZ?
zcmKaD^%oN)R1S;(nDgR
z@Igkz3Ekud6-3o(fe^55Tw2RgE4w$l>R;GjhQos>Ik4?)TD!XK{Nnv`Kmah)$3a2q
z7e3sD?&M~9qL(B^oM|2Fl+V;1CO>Mwl->-uh3OY6n7*1CUE8%CpN}aj3h8IR##u5a
zr|%}BUSD5t%4*pcpafXX$i$Q=a}F_u0R(SQ(%EF(e$uIa3Db0EbPAjW;!%EwX$BX0e+dT>iDK%L;80`;V
zJ3YIkZSR*Y;gyR2m>_wb^j}I~az3RIh!z%A8&vNR!DY;8p~?|QNVYIDW4%2s%NoCZ
zn?wzSwc!QMc_{fuB5u98oH}nldGe%l-{zeRJbZj+rlvS>gfpT$md?-e3WbJ8L$^K4dBV-}O@olHhxV%e
zS@lg}()jv@@$qqBmeiLoF-wDTxzOm`bT)YkE?=Bd4OC0qkh?lDN8egO;r&bzc?r8}
za``gWFPBN)mWkF2Xkz#7aHY1?>cN3sBO=;ZAsdfSdsH
zM_m#W8iex}vi~>H1t=K9`#4EJMtv8ynAhn#NK4mIkWCqi7KZP>5+YHLEjW
zT*-iw2WLrRHIy7#EO032RYJn2isRNfy^jHrK87bmJ6L4q62$XwOD5m?m-&ro2H;+8
zdlv6k_wn)a5)L?^#*QiW#QNrj279=OK7CU3G@am74rKKC31!ygl|qulFB3`S7Z6dZ~7umGET%Ks&a
zvE`=e+x!$0>y;fDieA2YMVuwH5$VP5^pkQEqg*T?X<>})u|d%%I5@ayu~!(!!fCy3
zjR-Ql1)kH?tRvRYWHakOw9ms?B|+F@u%x3f>B
zDeIOkSD~T6;k4@JjS)!^1MM?sd`i3FX~DS=&9tU^4zu466feQ=hq2U$_wTK389w=K
zrrsH#^k-rMIAvz2`RG*zvPNaWHC_gf$A?8W_TtgEuE>m58=5}K)|B+
zO9*tk2>6`*qUQjfQ5K8kl3s`+ef{N@vtweYHXW|H#Zyky;+{&hBwxEfakJ2W)Fn;_1}M+WM)YsOOC
zGz!GqDm3Z5p_SWCT@w$lG!~KJq<637tsEe^$V6e4oYHBO1JO&MA{cVosc*QonG|0NCVL$k?gg|u^FpJX`U?o5Ry0B*3CpFev%Xw%vckh(Bv-L&?$
zXSeenLBS!!QY$Q4$B(axu0C;;UW{A$?d#XJ7-b?}wE3BP=v`zuvszBsye^l*bPh-H
zx3#zF?Fdl`6+9mp60$o)CCT>}A7DKkFff=1h5G*Gks>Lvf62B6&Vyr4@UniOpRQYv
zJAhwW8b13`Fz(o6+&Lu&IOt9Q`(qN&SXXy3t7Yl2?H3+KWqJ7$*sc%3Eke{TcB;Ed
zJYTA-Ju$xrvXEZxVR^7Gt=t5!5jc#AFnC}v>rQ1&XptcyP**jcRLVuDnV}egpMCBq
zUCF2a=>Cd$ci1A;W+0H&n~2tOe9XF|&;_YDFenJdOPj^7M54f6g0VfDA3|ZCFG>Oj
z>Bu<64F}tXzM7+*476V01B6)!M6SO|)E@2{)VBiCKw#)#D~_39YMjUuNXB{MnW?GT
zNEktIB^(rQTghgs7h+OUFB>dwKf6Dz2~!zno_wO$=0W2?rYDZ_sI)>9f#6X6^{a{K
zHN8XB5eOOI(u?WMM4rSvIeCpEx#359dwWNRO?q>-{z!0>&%=jRU%!6+{22zo^|^1z
z7#1O)pse!##dOB=@1tcX_p#%-elBSMvwl+I*giV%AXF&KqVXn?)(mhaE4cGe_Lj?k
zZF+MKQ=D83SJ46OD1wLE2H9vMeSJ6R`#=S2d!BobD=c9MBk4B#T4IoaIv_L@=Y@3x
zd6JZWoj}lo*v3k)EWWDcKSJ=FNYjr#O!)ep;Cb7&5vO2&|F#I^vB__1?HT{p*a%Sy
z4*I!$UEjbriL2Hr7%F%~DzzSAAhS$TAke?eK(HSUBV4+e3Ea&ONvKs>@tVWfsRj?KJD
zUfZ%ilpaXPcy$DQbAABI8zzG=Qb5jyYSVfQS~nOk3Bxj$EnBWhM#M-zl}~GOw70*K
zsSAmx_xP-v2Rab$^!B*f*|a9S`~plX_crA=ip92=*z8(~g+kwo-dww0nAY}(SCY)e
zcgjW=c`VICL{O*j4R@gC}0C>|B38`ILjUI%BX0$Om6uaW>7U(
zcSEIuIPH#EZT{j_=yhCfVKz@MMtM;@LSLSgzw>~HyxU=9QDN7@XBSJht)JN*vCveP_;^Ay}pnmCgnvqNk9x}
zF%-z{QH7(o6D~9iH1eBOt9$LRo(B#bxIJ=@Hc~AMch}W*;eU(Z^$%*?X|OnqSsj5k
zwWv&m30uZnN~JJvCl`ll$x7Wdk1
z+jtl03ujhsWT_6O3>dZI?Eb9V@~LRN+(lYiT0KH?zqt4>Z!4|GPoK`iZy}676cl`b
z!WRTD(H(^gAgp$FcG}v^ZP$3q%*6=1AB-x7sal$v=tyovXZ!f=$B&n_=KrW*{pqoS
z+bcUWn-CDNIaBwl$X0zJ*0%F*@d)Y{FW^hvOnt4M&j_gtfNYWZ!yIYBRing;vAeloI!B0Vj~ja@+~N6t2mDLFNs^X^0WBv@%bt7w-VeC`d1Q|;os)K
z0bibzE+|MCG66C{ALaCyC`m^6<7l`$+t=;ruK<+TN$7*v`mx8DKtL?Pp=A#^hMp%R
zs4e!1F%Y#I<`F|7XfCdpjtel~?__gHYp{T~8;$i}IsCCcVMdMe;8Y!7ddA_(e3y|y
zoZ?K^@UJw53(haDEAT7q#FgP0449RSm*i(FHz$4FArlUEnw*zNdF!qsF}f$Jpfl#yk}t0Tv&xscazTi4pwJz<@k)LJ*h7-M?vYE6Omf
z$s&`*clRU9fjt}O>4ClOKYSR~>5TKpb1?2`B{vk(iC;!rhZz$}6vR|4L(Im|iZe;t
zFd|`0W0xayZaSErj?Mw68mFcXMXK2}c1_H|{7?ip#S7YBTsVXW5{LYax0tN4>icM#4jE)LZ&a4R@hnu)G&p1PDgEqaUU{+`<^S?qJ`Ff8FE4zAnHd8b9%Y<7e}-M_
zc6Y#AbYNP7KH>hfa(hlr4tP7JYl18UoRKZ*wTsuh!q9g2qG*^9`iqE&aTcU>0XaEO
z0KVYof9Ub*6OpY7QyD8PisszE!0yNKK!jFZ-dD>|P4;j*r)0lZtdHz+0$JL)FUBR#g0i(WoT58bh1c
zr8nnbQu%6n;NOz6{clOX_Kb^ceSjh&tgc0O1QsaxHn_PjYVzqJE~clZ*8J)>rSsku
zRE~KS8niOjlq*n)2hq9+*L~>Y$BK@Ree9$ni9zR;E8}(?=m{W{0DBBH{OfSuO_Mhh59m^jDh4R5I#;j}h^TE)kK=JZ(cT)U0+FOK5W8
zmC*BV(69G;kIX<{1+}k@y!?!vuB_{WHzC#X@32&i`WQ
z|9IeDyMd|sBT*x=2a$YOP57vwg)3(y2!D4b6z
zIn~#5i9GoGcU839XpgxTq;SY@@LKI+^y#l!)yb!@efhven
z29XOPbTG8yGEV!$neaD9{*UJ~O+P3h;aW6xpyoM_m6@5TFV3A!&O|2Tr3%JH%y?-U
zatCCu^dhKZu{x>|+E2gQ{`JrmaAqUcBngA$9Z#n*tcCtuX&Uzrld=Ab(|gd0a96iW
zjyN*hFa7xOV_6x#1nM!s9nH_x1DFjv!V(H7Tbzc^!h^wC^yF*j?8He}`k-0zpSM6A
zn46mm7VPDMgGci5ijuL&E7`t#rLno~^)0pgJE~#$0)<5=6vx{Ru~&UegOdd6LKa?M
zHp86`>9C`m`Yn*&+}hOCXDjIz{AIf!izSTU
zB?o8O78TQ);J)`S!h5C^I_+|xwqPg)&4XJ0b+Z+OaZ%B3Tgf{LJ3}k%C4oD9%1uCh
zlLsXutH#aNK1H7Z3Mm3CQ%dRHvw6{JwV&6MK6M*FUDgPXUY0&E}c|TQ`b_6RJk=kOrp>pkG@olq4*aF0xi$N8GcMU?xIQ_tsOUhYG!u0||It@9-ziil{V^#~#
z)JVRN-rN({lQuoR>L%VT2#$eGVW0tcg}H(vUwUZ^Of9i?{=!NhKkjvmdti7tUb^B=
z|I|F(H=+UpUlsyo4<58f9fUHitg(2%5pP0FdHla!_&0Jjh8_!N?y7eYQLA7iiHb5j
zeL7Y%iPs}UHw9;)GLWOUdCI}6K{lWm*GH~-kpZWly4=z?ynl-9?=Kqw=}jt9D-VZn
z(R_e~_ew}eph}>;?b=1WQiNK*pCkn{3Nvllx>{JpA@XddmcKIXdHEh{xsMOtp@VY;
z@ow&4P%hxi>u_kfia$0K!i@9~CbBPH@aMHzXX+*?^&N#c6-%;Pk))_4|A`K-Hm*Ht
zW0O|a6Dv(~87L1GwAbzsUNSg)hIlnuu6;5d<0x+s^wrNMqDJ4MJ0(DhF|>o&081`N
z%E2&IoKYXqkbs(p_Jxah1KE^3-mDO4;^yXd`gDM15>71wq46;GVzzzx@+pgZrPQ0L
zPoF=Z)L>B^ap>q=ckqGmN|?5STh)&++|d>QI2*xHFdPh<*)ShWQ7_R=i0j6{s=u6<
zIvGOY?RE6I`a-$4HF$UKynv_&g4fgm#TXf}<~sgIQ&sgVz?2Y+?*QE@rpw~t^qew;
zeI1i9yp-g234_W9fvp?wwhX^(wnA;h)#Fd&rGQ~WP&pl@)%0<&pkkD
z!M8}fW9D>S9%iH!@U{#)NPB-6w>uc1lmYJ`d{V{21KTz#-YfVsKCSyY5gl3+g}Tn`pgoph15JLk$OYVJTj&f}skI7R`*bwS4==JiEHw
z9eOz~)x`S!TOUAbLg}C!Zg`oTOn3kxx(PS&(Qt!i?%XNQ!-%8g8k?K@boKNA4}t;%
z^Yy*UdbY5zz-xe0M|-&RIwfMoLRWa~D)xWG=`0dbXXgFdgGifRJ7^8*Z{LC@d=#E^
zl0h`U20vyXZi70PqaXF;$-UoukGyF34XY2dsZIb?Hosp93wQAbyzr&8qU}yHQ3J25
zzf+W_xZ2OgBH%7)Cy((es555{;-n&rZ*S!n%vw>vAQHs!C)q^e_$9o@?V*#vKJXNP
zxbNJ#)7VqX;4-R!gS2v>WYmga<+kZx5a1n3nLN2coLcf&SF69er}S906{!r?@#e+nVFf{
z*}a{)zPtk0tT+DeZXsu{{qtl-8Dt$47ydt-*=~F;1e+W#q^K5f5;g~wPvR8`$mx5f-EiW2%=Lz@y}i@e
zh*LhXpaACXL2^*K?t7Dpq
zzV^Ag8jgve+%ec}2&K5D=8^v`=i8+hAyi}T!0CU&@$n;6AkXEA=)KIeZ_X{^a1rqu
zpWm-t#t!-^PC)e-H^a-LfEM{YLKI@Np{+79GP*tXRdL8`!;nsfQ{}9$pI^aLquy$_
z`!^aapt_S_CH;$8YrOxlt_KvA7V?YOT}F(Gf`gfJ^s7wM`Rrp2)8Mm@v*kJH1v&%U
z{1&{iPhO!06Rf5bJw9eyFNH3gyIDs|Pv@;%J3u1rqJMfTI`G~|=q5hF&FH5ex{jSV
zp+0T3K^N2#Q@REVl&%*qlwvig|9o`C+g+&xy+)CX0>yc5Q9*l6V
z(6Z*XjofG($5|m(VMBK2O9i)YDaH|JU4Y*)B_R$t04hJNG|fHw-|Z4(jFh05wPLgg
z`*{@J)QYr&QSOhu$SBt3<-1yd2zXmqSm2gr;o?$ncv>j3Ob)%V)UeXPi+u65m3kwaEAimMCf86PlM9$h@3F^=T&z;-4d9%FZqaCK1x<#<2(aX*n
zW8NQo?d?$-yb=oN^gLcq{DEH1t)9^Zv+zW<$fw^T+;ovxFw(O!Gpjm$E^`DN2Kxhq
zgZLOMsB{Q+IQs*Ki8;!OHRF!xzvwmrkU5)dFBM5z7h4R?6lFKTRxRByjSF*?<2))f
z)VClOQptHri4X@X@q!v0*%Oc>_?@WxrE+g~u6=1*#6-O_M1_fo2}EVj`5IOn
zUaB?!sE%`YxMp>a6zyEWn6td$l{g#8%4Sx_%EAIW=&7#vQ1#Kpe0Cr
zSKg?D=q#9>;@++IS;NJ|^li!SaNhhUD!TfHd65>yT~
z%cbl68q8_B-r~N|q?m=2_F+(1S9fbQFXe8EoBmCLAH8WA#_9Z$_RE1hdqOLAadT6z
zDq$8H#hX6~AnU&Us@7vV?|!(J}%S=d*KrZlqppEMnyY?6m&`y{|4
zF}drwpZRYK*l-PKkMnip<8|5HDUGjP_=*S9@Bl$z3<3-X$6J^
zyR^$3ciT`(0eIt=cNk97l3Z}jwS}J%u9@a?3;24z7e$
z!*C;X@lswqjF`Cl_doOtyF1VOB9N%O)WVVZwoNIBO7IJLSXfm7oe~>K9?E^=Si2F!
zhQYh1qPf=7TkZ^O-M)t{y6sr1cNqYS7-e~y-+sdY7j46K>^}GoxoH!v_&gaj!!o)gEieb?@0z1MN10r3n*ksR8}0
zH2x9SVjPFSML&#;37bQ%SLXwdJID3&ODmxc04Q4NwiU??tt?O7X-^&$EQ;E>At!Pk
zPob3M2!mge(4HZeB%6t7bD9Sq57^!E<|Nmj)w}#=Q@2uY6RhNYpO04h*{$Q_68oze
zrS5rOIn(fE^G0t9&9KC8p0cu}N3TJ!Z6#*PN?uuZmFUEiGjBnp4+$NYjwIb4-nrb~
zSH(VZ+TLfNvX4-=Y`o6U_xhqj@ZMjn@d%uSvKlSpxAbI`Ka0v&A9y@bNohUZ
zkJs!zz6+oxYdLgr;=nRLt$QHoXf&CjjNJWf<*^ik_oB
zLHMZ@_!@O?Ob!E5mEn7~kPov%<{cBn6{JXN$ed}_KmAcwLFNZr*7nAqNSId7RzXvC
zX~nhC<4Tf73weK#--v`nGdO0ntrfDOhkx^LAlW)~5GB+V2UQ~4rOTHWeVj>;!J{(Y
z_8>px`0?YCefrFC=yIPpOCogrxUV17(DydA(L*3IwrdFdF^Y@glg!Au3zWF4SD99j
z+Dfb<=8Tp1x@+`8%HT1b)Z*hcz6W?8TC_nW##<}Q^(bVrrF7lGE-Y
z-X48%UdqVVSR(MFfA2qTYnOc|C+Ktzc{6qT^#An3{+{u!Z6)r2_`Jd23M(KA>n~k;
zc?-y;%)o(NK1)kc%(QRxv+k0Sp5Dmp`8xd3U*ek?M-^9JUvVwvOPA7>VW;mH+0cb<
z-CBjL01YT_J85HP!+0@V2D*0Dp+nTwO~5UA;mEYa!~Fmpx8l0Uy~i1TV6IchoBq9f
zZv&8l4t8SxPp28i+9S$vBkc@&jBYH(7(3-fKzJ`oDwBn^Kx8*7)#X(i2%@(Zh^
zq@)^uXWkcN&eVW^8nZ{uxtzv?e966Ubv?U&NzuOmJ_h8*=;VK&n*l?*%M^6DV2k++
z1?OlZN4SVM`Wj_+?UlS;B$wENAb#+n;$e^5#6irOEdM1|Ne1
zhXSl$zkXw-JT>p_-Y+W=yx5P)*|~G~EYd~>>fu6Q4?_kh7wdLhp&DYZyZy@EnEBtT
z!dI`R{!=*5YVjRe5J$UMk{Q{StR@w{&=(2&%a?j>@kYL_dVYx8$ZOY&w`yC^n}Bc2
z&7)#3T@rH4ZlkwQrUhiY%b3`_3c<|^7sKck*AjjgY(J3N>4#N^HKvgUojZ4ipF)8}
z+<-WB{BV8cOz-uiH-3=36&}-YS
zNj*C)iq9DnbLx?A*d!&T^ba2vwUT!vHnahXenbvU^%J{1D4nIAy3ocyePVnOX
z-I#wWUsq1;EspU9QJus`$q0fqv#7_B%136As110y#52M5g-sfO+Dt^=1RmC-obQ)(
zmXT)srUe>?UDr^0qQerG<@}Y{g`>j0v$`J2-vqK>Qg2RSTXn?xl10?4^sk>V-_ZW{VP^5
zr|WUX;+Ki%p+h@i4m6j4Xc7`zn&r_)%K;<%smLP_*KFEg6KMc3l!PtbzFq5RR#yD)
z$C)V!#SIFCdd~Zj%{I54yU4^qniZ1v8}bPi5`z)2V97qKS6}~y4Rk$PI~(PIq#*+;
zuhNVEw_>xc?SzCX7i*Wxj!+7jq*UA~Jjzh+%)-9k=JlyNI5XI>q5QTj9U~snn62%r
znA%hn^5IsyCbjog%D1DVN%XS60|mQCF)=N1+xsn5itIBKIH+(RFe>jkk3dxyPdL_6Y|?^)Sr_*o4y~Ta{(kN`tk*9uvR&V
zro`WI*M1u6*~4JeIvgKO67;dYJFagE{VUJIMe0y59zG=EAF+9SUV+yy2u)IRWo9}b
znWpVcAxi7UUbAYIuswicn{Gri|IVOs
zehbZ4ug<}c0C4U5i^;Dbx=ort&uO9O1L4#i*>J^
z5S{pfMSo)!C2Q5Xl0A_&gNCFBwXj@40Zo!ATTy2UnwhEU
zDoxvl_BzCTtmswHeK;bGjV>Ihi?^f1r+Uj_X0aMkIsG|O|9%)TbiUG0<4b!ty^bTE
z&im)c>7P5|6X4x`cPneb|22=dy}5!>R?3EqYJxO0MvgSs??)*`p->>bqcfT<@9=<8
zPw!7H+-L9X+yKo%5XCVr?f7H5^@1anevFNur>3&3W*m7nY#Bvmg;AQv!jXpXO7OyD
zlRz|k49J#m0-vpP*?KLh&fwqYr)%D3xRulytEX-JB|71C16rE`F^#p625Z-@1wqgs
z;|nQy@Zm(*NLI=-Y$rpnV)6heUHw*P0($xVzm8i{Q%OnyQ=#^THw7nys}LqLr$_JE
zlCvSF(TodLqkz9PI15N5Ts@a+-tei|Kc{!aXu@6wK3toTbw055YI!E^1#L8u2X35<
z#~=Nys(MTHZc5sCy&>u%AnQR;DWEjG7ci6o2yXlpW})SMab_^~bib&Ja1}Uy>eNW7
zF01IBV%@bQXXEKCBs{@5C)4duCbGs!f(TLm`EjB2{*nUbtLa>0vhpn`OlyNy(57t@
zYaB0kY=?QI0fwfRM0~_qn;6_X|IMYIhJK
zhLk4~PUs*kd}4=_kKBNQq(MfIYLK`vaO}E5LYmZ)o@=zer9FyM8^7lmLl&XHD8a!|{MG
zt{#0q!(A>}b8N}|*zNfrx4iZiVJS1)^f&IB#XI5|t+}86DX#V1aeAfBZ|F@v$+z5^
zn>c$6-~9atF8K7%I1gD0bzF+HwUfa+xfk@%Te{zJh&7@$cjNGCU?EGLBR#!ZFi3pZ
z)0GojblWOZumu7gvR!;8KCgnBOHdy&LG(%aLN$lq`I@zBg9RC`A+~KWArjbR;ec6Y
z&eyM39I`EjOG*ICeo3L;N=usEc*&tYQTShd*tE7FX`@@H9;1)+;I7G1i~uxV|PQRd2JSk^%P
zfcKmR^^mziSij49ms4K70{%r7|K0eREeZl@6`OBmWjF=k)r;>GuYvy*R@YMnLP-KG
zlb-Nx)Q@sxAK3LTVmBGB;+Wg`=S2!`DBZfRXD&8l5u^YYW`%_jya9*^aAb<3S^uPF$K+PQ43`J$ttJv80Bg5fC_#okC{8BHMSxwM&XeZq%Ep>|ETqS_FZ7|Fuv?!#CFwJNuj#m}|d7-(-3IUI3=1%J&6uUIwA%Q9yry8j5zzCogAV4q7
zqf)+HXxxSg&q^$@>T^Fd6_xEtrh5kO{uZwfot04;H;NymJX1!F483w?6KwUu4-Pn+
zmft=nmkc~5v~BFNs7+j%(a%Nc#|-(W&pIV8bZxnu5_4PY6EP3>8;2JP2tJ5l>Zful
z!fSe$fgg)G1vt5m2>3uLdT6$HKtMcN1zb*-3k=HLP4~!SWi`K94+s+{lND@twrE|;
zfL&GpajqvwP30KhQVhpxOJurHmN#IF;c~kv8kBwY^@`F`VUrU0CV>lvC3Ma&cJvzAU_OHMhBH+skj0
zyG`y^CU$d=yT|#0d;8-z_=la*4-K>MFS0H(K6O3c+B_zH!!18Ug?rYRF{{9`YtUp#d9c~m4nbD=ls4~TGz>pVZMwKes-cAYX6DPh=D0-F)
zB|~|plTY&A<01-7-1xmBLA6*6^Dz)wdg*ZK*r1rNw{PA0$?79@ssoNwY{j#I;_Y__
z1mx1!2eB2&&#ymtbGX`X2dOz=E2mGN4kE1aH<_RaevCFYMJ~1-{6p6`m5eyEFlN)6
zVNVZBciT^S%KX){>UnwQ`}Z!auYmK3X_0#Mi^)(puZ4%}Em~9@ap~wJL=GV*s`7dq
z!7%fKz_EU13w3PnG^KbDFQKUbn%-Bxe^|W
z$M|w}0$B$MqnxQ?_oKP`QkULrf*P^S&JIwknam5q2D`|xp=7aCw0(&_n}VRhc1-b4
zEfT)|@ZozN`uE*zZJnB&3>LI-!Ga%ERSeXO9Map3yHo-s^lO&WAi-0TpK)5Pe_@)o
z$=^opZuZmKBy4#3DU9p-jzRx~2{#T5adpJA48xI_*z3FaAH-L5Fc1{z&^K?s<`v{_
zGwIB!ajQOk{;Y&!$J{P_5<)n$wnHZ@7g|_a;&pdiQ??-P#L-}RPp{%*#%-_g|NY~;
zCRo0DFeH!<>es*
z_EU2R$6t%WPj%JvO-d*czhgnL{^CUQB~q6%%VH}otRuc8uQzM_Gw()bZceCZ5+=4{
zPwUBg5E`xfHn&dBz8~c+8Z$w4O2I4Mv7=|AS-6^$JLU*NP&4_0mnmav>@^DtUcZ0e
zh;k)?x`MIbI3>qL4Bgln$5{LVM=Wv9Pp3bO>`~3XG+mc>mV#+!FoK5{`F>^%K0oEO
zKfRN0c@d_aU%nHumLe>q=0xxN`K;vnAz2CdEoM&+4&i1Br&VD{+HyDe%U(SS=oQLTVk=W+>_EO2srNS+3DENgTOf-
zD!aA1oZzkM|V6@tTwK>CKGPwQpfEY(v^6l5L@Zau1|ZgI6J}8C||JLhrJ$U=Pw?R>f6kI>BKl4p!ZaY3{XdhqGJDgK$^-
zSSzx8i5MlW^;*e#(wTAnwQsKhW)5B)G4VxCAab+5hn;ImYlOud)H&$ErPW=gO0T_`
z@meW?n&+qq3kVizUwZp%x_Gr)cWiXG*xP?|+#^G^JP{zPlTA0xCFz`2Dx>U*
z%eg{Z`u@zr;%bs);RdzJN~?Q@f5wXv|BC&sx8~ash;N&el_FkM?3~_&-60rsU?Z3`!)!KEZHB{Sxb_2VnY)W
z=X(n}ucTwm74ek}#Gn*0jW7#XdN+_N-Oc_dW584PMLXfN;TU#%YvEi_tF0$G#nFE;
zDu-xopP9)7ntw^vX-#|klT1AhCmuQdrOMIRv_X_i#8R?;&q!%G8#sNT6VRM*+itgJ
zL1E$KwU72f-B18V4nKDGzD9z{eY&R}#*bR44)2qa1esg6p42ddNao7e)-UgErA29an;pOBWB!`gZ1LkGvl%6h&8aQroTA7`N7CruW79
za*xt24#188k?PiN8$2kTs5MZ(#${a58BCJKgng8vIe-l~Dt
zwm5%bZo~E@9c9nQyN=5xKTSz8za4*B{%ZM}xW)icXxbt%q)Kd0;&kk;L|lND&yl6-
zEthCEapvz|448;cm~bxA(|h^+xf7Tg1B>f}V%{jhdfWKLI*XMQ@80OB|M|JJqqMB{
z4;E?Ob*Z;w;d1|RUC$zb2G**&X%^|{bu(~Yn!TakB1v&Okuiknq4D`q!pdiU9ENG@
z4?B_d?cHnTnetM<>+6MWue{@S?b@B~R${5-k9>q^J#pGJwD|1W48bjBg+b=}NlXH6
z%sR~zLQy|4Ut3dC)5fOa%90SaB_um;E#M`Z7G^wo>+V_{ZT$}MhjowNEf-BQ)BS_6
z$pfdBbFY>1X55aSH{Wf7xYpEZ(`wM;WA@BhTPZK~u5$NAWua~o$yTj#O0xhLzSdly2qCR>WTSJ99Lm^Rr~aZ
z@eZ`eLY%N>
z`1NbdODY?~0a+=E8JbOm11W&{r5T4Wy{JT6$#%1b;o5fe!B+NfpJG#+mzRL8QNoA^
zUFLgRscqg^I|A*IcV8zy;deVMC#mSc4F$(sY=Sq!hUKB%`zujU7}-l_L-^~V-UP8UFt&-3OE+L
zSVFvgxO7WYa}N)TcWe8=i7YN*965FBak=c8VUf;5wQuI?y@ezrDS@@`+#~%bqPgZk
zb85*NmcB)!tFBiP+@
zBr#>iYiNgzXgB$r+jb7ebDq7Q)|^z{sDtZP3@fQ?SUge`p`wh&nHeUJ-D;J8Xs#Vx
z>=dgF9f9SeS9`T)B!jmy8lOZVx&ebaxQ%m$Ey>JZ*q|V%O*v2zQ#DE38`F^o?(G=l
z^&YwK&g8z)p|q6LcLD&0n6i2L_Ir~_ECTV%D*IDussHig5g6OPe*OAr(@A`l1qY8{
z9a58yit2mFBb;8C1$e?(r57*et)7A~xaH%_Sfi#_l}M)Q>gp5*yuFrD8q>W)|Jh4U
z;=pYg9n+``IT)aGz=u*1#przZnWB&rF$$GfFg7wS9i#Mfp^40w`?TJ{p$ve8=Kzf!
z)c2>~#C3pq{j+=D3)$p<54?ht0^Qao|87`jS+?P|&`@(8U65PTPEE}Rq@8oFzb!Br
z*
z_b!(IwyD|L?KAJOxA;d^Zlf$B+hS9B0cmh;&`NVdQV-lsBu&rOdN9G_f*t5C{SK}K
zMUO77<0j5FtYppXd$!d2q1+7JG`26y*VYEGTq7b(#C=~uQ!!ZBWXtHSp>{IjzlHD+
zqDI@mgoTpM`!Y{KSoitMm+ZRGuGE2;&5iN3%M*n|d)?Lm{orMmtr=yaAefju84QRu
z(78=rg=xpz!OhQV$uBIYtFCrtkJ`pm|2_i;J}-}XtE9Vzy*X4&&EN@EpU+xFWxL?4
ziv<|`-g~UFZhmnDlNrGI&01d=+8axR)cDca|Idh&Ye0g8Mfp=0;D5;LgYQGG)`Q{mzv+wiIN7s+<518LnSVhc^RR+
zLYE$C@S-ljT1O{^aRCz^a@c<{z2|pc%&pF4gow1h_k
zg=`Dxh_d>2C&)oruU^@rapKcKqq@EC>ov9>af*a(0Awm_jdS-8KQuK}&ii(*>h7{J
zySNZ6r3uv!Q(beNG=k@R;Ei=lU3Ts2)P3NS;>nE@ep+&Fu9~v)sVavY!YN|S
z$%a0HZbLyq!N@_BfQ$#UMfAzEYu8t-iQnN>Hg_BwT3NVWURLIOqm$f-5lsF!;P~+F
zo9AeJ@RO1RVXiRP=GX9q%#@kN@PklKldGYo77tMC{PJiAElJ*NevGxDpe)!h0jo4@
zqdIoYk-#GL%a=LcaxAqeo(oQfk+^_%*b>h{9pq*xK?5DBX`
zZqk7GMB9T76l$KLVLcU}%0RCd?>?W!B!g30=$uCYrtevU{`cX-;PFkDxjrLQU-270
z^lHU7oBro$;q-<-e&55fHc#xJj=_U<*cBNZyq3;PVD?iqOf7kCCZ~OM*;SBz_G#I|
z$eMKKNZHXrN&|Hfcmfjpo;VTwX44&;PE#4uojQB=TXAuc;}@W%_2%Z2OipcM6kD5J
z8Zw#TDx)M;Sk3pol|5rT=5Ku9OyiaZrn&Nex?MmB)>{bxz`rRN91+ky)cexDQv2-W
z$P@pJwr^;MyMI}kU{W~&fvc>nyH{*(k6;T`4UJ|2sfgaZ5@pgu(}I{G5&vL%%TmRz
z(zR?N`9luQwR-!00Ot{X$A%C)0P|eAgz*%NxEB0>Pt_ID510X`>T+foO84CRX-Wx%
zJHa^%EHF1*=v&chs3B5<{XWC#XF<#W|4`<3!W4tPq`0UEN2;u%!8xWIT1318QOUf~
zv__duhHWturG2MmqH=!lK=WxzY0YoGG*l~~uV0IDKjYz3QSownzn16p+IMJM-h5nK
zjc&30_d+MsfqfU#?&7>QilB{x@?%`sj-e7Whn>Ktcq6GEC}fA7-KPjX71r*;{y6-y
z&YW4bWXbL~JMW~y07@~LxyHmq*ohgrf&5HzW2@Mc(>&!3}KBC2-uU9hjM
z1Z?|@Z{3b12{nAApPaUuj9;il&L$;xxmE!Njh--}I4)55AeZ#J4^-NOfQt{(7iT`@
zb&CB#kZZy9ST6sWh|gO!woBRi^#}zZa`mW_uhWzSj|H_|&9NE?RyVztRj#-nEME$)
zzhmnxZ$X{)<^S`xxUb@MdjcW}PBc@%*w`~=COLD07cV?BX#*rap824P
zwe(FKNN9Rd;7a5yiW~dnleYqfYkR*c#)Ur&U~~am7JLm3CsHor{3+hPMVD3Qa!*tC
zy!>-3<=*0J5iidTq26rKLS4&HFo-~z7?u86XF>uy?H=lHwSm|>dTA(m_vzSx)S^d^
zX2wep>s^dQIr!TnTbY)ZYkHaxM7i}%=^{OQ#NmscvJ!lCo+iAcu}VrOua)fd4<$6?
z6L%jO6yqq?X}(C!o#HK*dvgagTAyT89{kUOOGHSHGyjeALSo{aOZqz<9g(6!b;Oym
zeY>Dnqa-d^Pdz7l@P6~o%Q3|rb<>(vXDv$msWGAC3aJb0tGhmPtWJRd9y!8IJ+e~y
z%tB6R%%6l=;1#VQ*HqfItmTu7#Utt!NH15fjtQ5JoSnP-XUq{fZ55T<;FtGU7EVDO
z_-e}d5S*x}Evb%CBIA>=zIw+2*@H1BYGal-UeYfqF7AgLyQHM#z=2m+T%)bX?f3;~
zN=q`(Ei`ZJ-TT$?fxw`0ocDUw7%ViI^6AL+dO9{u$(XpBp8mvfL&p
zDk|QC*#`Gkt`|Uj_x_5E*O7w_VoZ4>bMn0v4r$8rOtL9|p^PAj;K%vr*N>&8V@}MU
z@BO*-T+g|PY_X3yRiY
zJej;6-c6a_fLTk@@2f9jN&zG@r>u6}6fOj@*;EMmB{0X>pz&hv){fBXso>&cW4E>y
z`CHq{MU!Z+@1^#toM>CSSeNuGOHlL;RIxc*v+W&sguLB^7a@@%P=BbpsTyV#kt$l&f*?g
zdphoPcHZ{Czl30h;pCKmXX~D_x!;x>4ys|m)pLkCzU2nnEcQG+4h5LXgrOVF=G-0+
zMoJ7*QnE+)MB0?VWkhxk1a;(;5mq(AN3Yy_&kNW+(kzi2b`H+^xpOb;hJNT~DSZ+r
z^D(|-6crVR4ZFY@WXx8B4tML;k_E$m1a4(ii<6{pnL-w+D*d+Y8s#xi?bryO^W)li
ze#`H*kZtWg#j#A7pRb?VYRv>owT|((Zk@a!AMPAEx&3b0sZ;Bir-Q=ZT{tqT=q>LZ
zW>g+P0=O#b%;K)_M?QW$A;J?_yYO&_Ci!V-m~0Zuh~?_l
z=f6~jayfwPz&Yim?DD#{d<*;kIZCJlP#VCjv3YWil@+A9%R#PAq(s&&S(d$JtoO4-
zuwLU&j}i^mQ$qb?Wxb!
zt{qyqVE`)u_(uu2ZLu@+Z|vl`{HU#+cPC3vT&u3W9#Y3wD63U?6XwL>x
zR=eSsqk4T{eRyyVdlV7rthf3BtQ
zO_{sFoGi;lUN=fa7K&)!s3)2~{(@aN9((SgyPV~Hp9=)LRX3kxX5OAG{m5ZHp_JhS
z+!*t!y}ykmJp2^bKEfcjFAe+CS2F;aJ+8r=X84m^Z|Wfn#tyjO$oImruwKwsT)7fq
z`UZ4Wp9Sx+v9Qer%ou>t)z#I+#AHRo8;21WLFgJ(G1YN>ZcNB{TVqpvS7m7kygOr~;=oHnf#7MP#mKiF>B60yDSCHYe7CgHK;
zRfH|lQp5PJ;vVE1rbCMQSbL~fbAWd-P^%1FX{8`V(;8hG+YHI0&XT3iIe(b
zh4~)*XlWQGwi2CIxVL3oUxaF5%YfY1YIW88fesS<{1VtAH;%QtsLVk
z;!b@6@&eQWG4$9umv)W_&rvZbE-h81c=TP6ST|!44L?&|!B}g~M8h-PLHgipv{jLL
z?b|xZm6%IV@XsC=sJF3S=i}QY1<@kmLZGQ|#0-nSZpDyKV0>{3FvC02JPwyo{JfK_
zQr%cJVK{FBoOATG=EbL}yMHs63Ud5(2%HBGoL@$ab66L=eY+QnT&C~*L0RJT>)RpY
z5q@*heu9<5r;fGRyB%#j=?3uW$VyskZC%~#SFf7gom5DHcs4L_tAi-Q7<=tp9x^rR(c{P9W65m|jPYOKZ=~;n2Ktlq^u5PT
zM*5IVE4bk0nKy#^jJ!%5XXZR_$S&O7!ZXWO8DHZtUuZa&(3+C8BxW4}gMMnJDe0z3%~>KvIS)s{27=t4$6N0S`pS$
z#qrnhmLm-Wn-S1rO6I{)O
zBYPJnW&;Ms+K6DcxPRLQ)Je?aLC9mzCKaw4UtM^LI8W4Bv-68DpDdo$M3!uJA#fCuo;*=B*uiW^CSiSPdKj4E!@(8cc<5i9YqHO0Sa$8&m5GZh
zG92cn5%~_JaZG<
zPkx(UdK+z*u3QN(?ibFv#&;dxgzmV;K7>jRE~!<$uAsx*nbEX~Cw+alf9<6ngeIiY
z!L>v|^F}6)J7q*xQVEy}co-bA=))bJ<@%)-!P|k)!6K>?^Dkytf?~(oJYTSW(kkZI
zEHqgam&fMOJGXApct$NbyK2~pE4=PJ>vak~!C`CMZYq$Vk
zTta)+l^0XN8f9eItP}gco_8%U8gyEivLwE>;_xdyg}niQn?1XBjhZ?A14dUtY7Q@z
zd;h)<9jP!fX)qmM79gL2f!~HX%!3>$xq2AS^#07hXO?ZZ1>dKX=vQPbH^|Hldw=2eNx-S^=}JXd3YOEn)##xgJzTh
z&?>CDDTgdH`M17)2E=@*-P@ST=lpC8q}wk4y57d~0y?7tW~|uq
zN=q}Rx?voD3f{<@FXw0}2OrCPbL|`ZS+0hMtHX1|3l)f+obS-Ap!1
z2)H+w#0Cco6Gd8bj_rfD!-9)m5uUXup`)_T!a
zsN+t*W5+N2Xy7zsul47ie}M^b-0WckrdTe+SWUWyqz0%#`3oi^T{EDVe){9b-Frpk
z*8kc*oc%x4=d<>An}!wejHi4sz$9VEEAzN9zMf?}27UV?R}v4oiy|7B0S$bo!4m>c
zpWgVeKQ?v(P3}_n9GoQ9EB0rpU|>*?8_5Dh4j}=bYtZBmg8Yu|23vFFm=Q~YE?nVn
z{rF+0>>2eiEsdp0@1M`}6g{!llE^(=R#EXghnwJVGh|l|Hx^?vHj6MEb{({=k7Ct7OAHF&OQg3LKK<=ra
zhWS;h-%UsmN5ChwF9U|(qxQX?xD`K0l9c2>+AQ5
zN?g@PQc@A#R9n8;(01_eMaRSx6&DLzu1J$RwtA}~Ann@KneDfOS#=_SYHH1&Xzy1T
zK(k;=Oe3W_5$j05%krgEvQ&HY|NVi40zW)|_RN6Ak@J#-tu*uHC@1RU?|EHzQqm1r
zDEOix(EC9Z1V{5mSQuYcYR=ZYfm_T`OcUs#qaD$3#xsfnh+fRnvJ?dS%=njs*@>bb
zHrP>Bg!76OwgnX93-as-7&mcZ6@}mJ)5*4IxN){ZBS>_~v3i2L1b}S!T#J@2@g>y?gR0}8CWZAOy^VU7wy?eKC(EdC=MqJa??S4%M?fCUcEeVXb{bA7bu6PsM=F&D+u80F?yrg|LvOOtmO1RD5%Qi_nUdcal}~R)
zPk5(7MEs2#-gby)RYZ4=&9(|>tq}Y@u!uGe(P
zylh^{ukYjL)=Z)Jg71hyo>k)(#((?_sZ;cjB?b{uVN(-QlPMFVn@f@soM(wWsD}Wa))x+!o|-7>q!J7><-otVJ(3<^
z8$oiX$fNh6Q40@fZ-^*~p0oN<*9mpMf3wEm)CxxL+0mO%%fMVwRo%aLFH;)Bd#y{M
z;uKrY%Y!ZnCa8GNczfGX%hG_uV<4Bm++1#N*0hG|^WD9XQ?jS_Z&JYM=-w-b8Plhe
zagU!pD+IwPC82>fQaE<>sNntpRtBtSH7$S^l(8;&1PA10YHGr+hM0$@58h9|wG>)8
zOf&$&$NIZ`lCku0CD5=?P|g1$YOz4o?N=9E`U{kXwni1Pb@HC97f8U*p4M3y1q7;P
zLJrK__B~L={_Eo4#n0xC_76q2_|qvNK3>f^*p9fOgwhoR(7kPF%M?C}_x1je*M0AjlLjL1AAO3TAmVH6wjGXHU0JKR$F;g`45R
zjf`NgKuGIa*
z0IGCud;8rFK6O#jMS1eMsHll?Dxsb*h69DLu7%Z2Sy@+NAv0F_J9wvjA*7e@gc@i}
z@c^1cxNasmtvEj;ZSjP*_}8Ul9#pAx3r`1$<+oL+8dNa(#|)8(5V
z^M|cl*M?2iO=E~iBDg0E
zx5CwKPUF*paGjVvEV2L{kTYKo`Y2Ut#GN|^wAs4^tH( 
+