diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md deleted file mode 100644 index fabab73..0000000 --- a/.github/pull_request_template.md +++ /dev/null @@ -1,5 +0,0 @@ -## Proposed Changes - -- -- -- diff --git a/.github/workflows/check-python.yaml b/.github/workflows/check-python.yaml index 9cb918d..82a215a 100644 --- a/.github/workflows/check-python.yaml +++ b/.github/workflows/check-python.yaml @@ -51,6 +51,11 @@ jobs: - name: Run tests shell: bash + env: + FRONTEND_TEMPLATE_URL: gh:algorandfoundation/algokit-react-frontend-template # If not provided Defaults to algokit production template + FRONTEND_TEMPLATE_REF: prep/beta-release + PYTHON_CONTRACT_TEMPLATE_REF: prep/beta-release + TYPESCRIPT_CONTRACT_TEMPLATE_REF: prep/beta-release run: | set -o pipefail poetry run pytest --junitxml=pytest-junit.xml -n 1 diff --git a/copier.yaml b/copier.yaml index b5996b1..e0b3ea2 100644 --- a/copier.yaml +++ b/copier.yaml @@ -9,7 +9,10 @@ _tasks: -a include_github_workflow_template "no"' - "echo '==== 2/4 - Initializing frontend template ===='" - - 'algokit init -t react -n {{ project_name }}-frontend --no-git --no-ide --no-bootstrap + - 'algokit init {{ "--template-url \"" ~ (frontend_template_url if frontend_template_url else "gh:algorandfoundation/algokit-react-frontend-template") ~ "\" --UNSAFE-SECURITY-accept-template-url" if (frontend_template_url or frontend_template_ref) else "-t react" }} -n {{ project_name }}-frontend --no-git --no-ide --no-bootstrap + {% if frontend_template_ref %} + --template-url-ref "{{ frontend_template_ref }}" + {% endif %} -a author_email "{{ author_email }}" -a author_name "{{ author_name }}" -a preset_name "{{ preset_name }}" @@ -19,7 +22,10 @@ _tasks: -a use_github_actions "{{ use_github_actions }}"' - "echo '==== 3/4 - Initializing contract template ===='" - - 'algokit init -t {{ contract_template }} -n {{ project_name }}-contracts --no-git --no-ide --no-bootstrap + - 'algokit init {{ "--template-url \"" ~ (contract_template_url if contract_template_url else ("gh:algorandfoundation/algokit-python-template" if contract_template == "python" else "gh:algorandfoundation/algokit-typescript-template" if contract_template == "typescript" else "gh:algorand-devrel/tealscript-algokit-template")) ~ "\" --UNSAFE-SECURITY-accept-template-url" if (contract_template_url or contract_template_ref) else "-t " ~ contract_template }} -n {{ project_name }}-contracts --no-git --no-ide --no-bootstrap + {% if contract_template_ref %} + --template-url-ref "{{ contract_template_ref }}" + {% endif %} -a author_email "{{ author_email }}" -a author_name "{{ author_name }}" -a preset_name "{{ preset_name }}" @@ -50,6 +56,30 @@ contract_template: TealScript: tealscript default: python +frontend_template_url: + type: str + help: Override source URL for frontend child template. + when: false + default: '' + +frontend_template_ref: + type: str + help: Override git ref (branch/tag) for frontend child template. + when: false + default: '' + +contract_template_url: + type: str + help: Override source URL for contract child template. + when: false + default: '' + +contract_template_ref: + type: str + help: Override git ref (branch/tag) for contract child template. + when: false + default: '' + project_name: type: str help: Name for this project. diff --git a/examples/p-py/.algokit/.copier-answers.yml b/examples/p-py/.algokit/.copier-answers.yml index 24a5aee..63a5c4d 100644 --- a/examples/p-py/.algokit/.copier-answers.yml +++ b/examples/p-py/.algokit/.copier-answers.yml @@ -1,6 +1,6 @@ # Changes here will be overwritten by Copier; NEVER EDIT MANUALLY -_commit: -_src_path: +_commit: 2.1.8-10-g72c45ae +_src_path: /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpccp2c3vt/template author_email: None author_name: None cloud_provider: netlify diff --git a/examples/p-py/projects/p-py-contracts/.algokit/.copier-answers.yml b/examples/p-py/projects/p-py-contracts/.algokit/.copier-answers.yml index eb301fd..ac678d7 100644 --- a/examples/p-py/projects/p-py-contracts/.algokit/.copier-answers.yml +++ b/examples/p-py/projects/p-py-contracts/.algokit/.copier-answers.yml @@ -1,5 +1,5 @@ # Changes here will be overwritten by Copier; NEVER EDIT MANUALLY -_commit: 1.8.1 +_commit: 1.8.1-13-g270c4a5 _src_path: gh:algorandfoundation/algokit-python-template author_email: None author_name: None diff --git a/examples/p-py/projects/p-py-contracts/.algokit/generators/create_contract/smart_contracts/{{ contract_name }}/deploy_config.py.j2 b/examples/p-py/projects/p-py-contracts/.algokit/generators/create_contract/smart_contracts/{{ contract_name }}/deploy_config.py.j2 index a2ff46d..194ba5e 100644 --- a/examples/p-py/projects/p-py-contracts/.algokit/generators/create_contract/smart_contracts/{{ contract_name }}/deploy_config.py.j2 +++ b/examples/p-py/projects/p-py-contracts/.algokit/generators/create_contract/smart_contracts/{{ contract_name }}/deploy_config.py.j2 @@ -16,7 +16,7 @@ def deploy() -> None: deployer_ = algorand.account.from_environment("DEPLOYER") factory = algorand.client.get_typed_app_factory( - {{ contract_name.split('_')|map('capitalize')|join }}Factory, default_sender=deployer_.address + {{ contract_name.split('_')|map('capitalize')|join }}Factory, default_sender=deployer_.addr ) app_client, result = factory.deploy( @@ -31,7 +31,7 @@ def deploy() -> None: algorand.send.payment( algokit_utils.PaymentParams( amount=algokit_utils.AlgoAmount(algo=1), - sender=deployer_.address, + sender=deployer_.addr, receiver=app_client.app_address, ) ) diff --git a/examples/p-py/projects/p-py-contracts/pyproject.toml b/examples/p-py/projects/p-py-contracts/pyproject.toml index ad5bfb8..e8c0604 100644 --- a/examples/p-py/projects/p-py-contracts/pyproject.toml +++ b/examples/p-py/projects/p-py-contracts/pyproject.toml @@ -8,13 +8,13 @@ package-mode = false [tool.poetry.dependencies] python = "^3.12" -algokit-utils = "^4.0.0" +algokit-utils = "^5.0.0a13" python-dotenv = "^1.0.0" algorand-python = "^3" -algorand-python-testing = "^1" +algorand-python-testing = {git = "https://github.com/algorandfoundation/algorand-python-testing.git", branch = "refactor/util-v5"} [tool.poetry.group.dev.dependencies] -algokit-client-generator = "^2.1.0" +algokit-client-generator = "^3.0.0a3" black = {extras = ["d"], version = "*"} ruff = "^0.9.4" mypy = "^1" @@ -58,9 +58,8 @@ disallow_any_unimported = true disallow_any_expr = true disallow_any_decorated = true disallow_any_explicit = true -untyped_calls_exclude = ["algosdk"] # Remove if you prefer to use mypy's default behavior against -# untyped algosdk types +# untyped types [[tool.mypy.overrides]] module = "tests.*" disallow_any_expr = false diff --git a/examples/p-py/projects/p-py-contracts/smart_contracts/hello_world/deploy_config.py b/examples/p-py/projects/p-py-contracts/smart_contracts/hello_world/deploy_config.py index 364edf6..cf0bb15 100644 --- a/examples/p-py/projects/p-py-contracts/smart_contracts/hello_world/deploy_config.py +++ b/examples/p-py/projects/p-py-contracts/smart_contracts/hello_world/deploy_config.py @@ -16,7 +16,7 @@ def deploy() -> None: deployer_ = algorand.account.from_environment("DEPLOYER") factory = algorand.client.get_typed_app_factory( - HelloWorldFactory, default_sender=deployer_.address + HelloWorldFactory, default_sender=deployer_.addr ) app_client, result = factory.deploy( @@ -31,7 +31,7 @@ def deploy() -> None: algorand.send.payment( algokit_utils.PaymentParams( amount=algokit_utils.AlgoAmount(algo=1), - sender=deployer_.address, + sender=deployer_.addr, receiver=app_client.app_address, ) ) diff --git a/examples/p-py/projects/p-py-contracts/tests/hello_world_client_test.py b/examples/p-py/projects/p-py-contracts/tests/hello_world_client_test.py index 6a9c447..1ce278f 100644 --- a/examples/p-py/projects/p-py-contracts/tests/hello_world_client_test.py +++ b/examples/p-py/projects/p-py-contracts/tests/hello_world_client_test.py @@ -1,9 +1,9 @@ import algokit_utils import pytest from algokit_utils import ( + AddressWithSigners, AlgoAmount, AlgorandClient, - SigningAccount, ) from smart_contracts.artifacts.hello_world.hello_world_client import ( @@ -13,20 +13,20 @@ @pytest.fixture() -def deployer(algorand_client: AlgorandClient) -> SigningAccount: +def deployer(algorand_client: AlgorandClient) -> AddressWithSigners: account = algorand_client.account.from_environment("DEPLOYER") algorand_client.account.ensure_funded_from_environment( - account_to_fund=account.address, min_spending_balance=AlgoAmount.from_algo(10) + account_to_fund=account.addr, min_spending_balance=AlgoAmount.from_algo(10) ) return account @pytest.fixture() def hello_world_client( - algorand_client: AlgorandClient, deployer: SigningAccount + algorand_client: AlgorandClient, deployer: AddressWithSigners ) -> HelloWorldClient: factory = algorand_client.client.get_typed_app_factory( - HelloWorldFactory, default_sender=deployer.address + HelloWorldFactory, default_sender=deployer.addr ) client, _ = factory.deploy( @@ -52,4 +52,4 @@ def test_simulate_says_hello_with_correct_budget_consumed( ) assert result.returns[0].value == "Hello, World" assert result.returns[1].value == "Hello, Jane" - assert result.simulate_response["txn-groups"][0]["app-budget-consumed"] < 100 + assert result.simulate_response.txn_groups[0].app_budget_consumed < 100 diff --git a/examples/p-py/projects/p-py-frontend/.algokit/.copier-answers.yml b/examples/p-py/projects/p-py-frontend/.algokit/.copier-answers.yml index cfeea6e..7af32d8 100644 --- a/examples/p-py/projects/p-py-frontend/.algokit/.copier-answers.yml +++ b/examples/p-py/projects/p-py-frontend/.algokit/.copier-answers.yml @@ -1,5 +1,5 @@ # Changes here will be overwritten by Copier; NEVER EDIT MANUALLY -_commit: 1.1.1 +_commit: 1.1.1-13-gc5abe59 _src_path: gh:algorandfoundation/algokit-react-frontend-template author_email: None author_name: None diff --git a/examples/p-py/projects/p-py-frontend/.env.template b/examples/p-py/projects/p-py-frontend/.env.template index eb4b229..5dfbb2d 100644 --- a/examples/p-py/projects/p-py-frontend/.env.template +++ b/examples/p-py/projects/p-py-frontend/.env.template @@ -65,3 +65,6 @@ VITE_KMD_PASSWORD="" # VITE_INDEXER_SERVER="https://mainnet-idx.algonode.cloud" # VITE_INDEXER_PORT="" + +# Add your Web3Auth Client ID here if you want to test Web3Auth integration on TestNet or Mainnet +# VITE_WEB3_AUTH_CLIENT_ID="" \ No newline at end of file diff --git a/examples/p-py/projects/p-py-frontend/package.json b/examples/p-py/projects/p-py-frontend/package.json index bac0511..1704502 100644 --- a/examples/p-py/projects/p-py-frontend/package.json +++ b/examples/p-py/projects/p-py-frontend/package.json @@ -12,7 +12,7 @@ "npm": ">=9.0" }, "devDependencies": { - "@algorandfoundation/algokit-client-generator": "^5.0.0", + "@algorandfoundation/algokit-client-generator": "^7.0.0-alpha.5", "@types/node": "^18.17.14", "@types/react": "^18.2.11", "@types/react-dom": "^18.2.4", @@ -35,12 +35,12 @@ "vite-plugin-node-polyfills": "^0.22.0" }, "dependencies": { - "@algorandfoundation/algokit-utils": "^9.0.0", + "@algorandfoundation/algokit-utils": "^10.0.0-alpha.40", "@blockshake/defly-connect": "^1.2.1", "@perawallet/connect": "^1.4.1", - "@txnlab/use-wallet": "^4.0.0", - "@txnlab/use-wallet-react": "^4.0.0", - "algosdk": "^3.0.0", + "@txnlab/use-wallet": "^4.6.0", + "@txnlab/use-wallet-react": "^4.6.0", + "@web3auth/modal": "^9.7.0", "daisyui": "^4.0.0", "notistack": "^3.0.1", "react": "^18.2.0", diff --git a/examples/p-py/projects/p-py-frontend/src/components/AppCalls.tsx b/examples/p-py/projects/p-py-frontend/src/components/AppCalls.tsx index 1268994..55fb808 100644 --- a/examples/p-py/projects/p-py-frontend/src/components/AppCalls.tsx +++ b/examples/p-py/projects/p-py-frontend/src/components/AppCalls.tsx @@ -5,6 +5,7 @@ import { HelloWorldFactory } from '../contracts/HelloWorld' import { OnSchemaBreak, OnUpdate } from '@algorandfoundation/algokit-utils/types/app' import { getAlgodConfigFromViteEnvironment, getIndexerConfigFromViteEnvironment } from '../utils/network/getAlgoClientConfigs' import { AlgorandClient } from '@algorandfoundation/algokit-utils' +import { encodeTransactionRaw } from '@algorandfoundation/algokit-utils/transact' interface AppCallsInterface { openModal: boolean @@ -15,7 +16,7 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { const [loading, setLoading] = useState(false) const [contractInput, setContractInput] = useState('') const { enqueueSnackbar } = useSnackbar() - const { transactionSigner, activeAddress } = useWallet() + const { signTransactions, activeAddress } = useWallet() const algodConfig = getAlgodConfigFromViteEnvironment() const indexerConfig = getIndexerConfigFromViteEnvironment() @@ -23,7 +24,11 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { algodConfig, indexerConfig, }) - algorand.setDefaultSigner(transactionSigner) + algorand.setDefaultSigner(async (txnGroup, indexesToSign) => { + const encoded = txnGroup.map((txn) => encodeTransactionRaw(txn)) + const signed = await signTransactions(encoded, indexesToSign) + return signed.filter((s): s is Uint8Array => s !== null) + }) const sendAppCall = async () => { setLoading(true) diff --git a/examples/p-py/projects/p-py-frontend/src/components/Transact.tsx b/examples/p-py/projects/p-py-frontend/src/components/Transact.tsx index 2ba3e96..3f8191d 100644 --- a/examples/p-py/projects/p-py-frontend/src/components/Transact.tsx +++ b/examples/p-py/projects/p-py-frontend/src/components/Transact.tsx @@ -1,4 +1,5 @@ import { algo, AlgorandClient } from '@algorandfoundation/algokit-utils' +import { encodeTransactionRaw } from '@algorandfoundation/algokit-utils/transact' import { useWallet } from '@txnlab/use-wallet-react' import { useSnackbar } from 'notistack' import { useState } from 'react' @@ -18,12 +19,12 @@ const Transact = ({ openModal, setModalState }: TransactInterface) => { const { enqueueSnackbar } = useSnackbar() - const { transactionSigner, activeAddress } = useWallet() + const { signTransactions, activeAddress } = useWallet() const handleSubmitAlgo = async () => { setLoading(true) - if (!transactionSigner || !activeAddress) { + if (!signTransactions || !activeAddress) { enqueueSnackbar('Please connect wallet first', { variant: 'warning' }) return } @@ -31,7 +32,11 @@ const Transact = ({ openModal, setModalState }: TransactInterface) => { try { enqueueSnackbar('Sending transaction...', { variant: 'info' }) const result = await algorand.send.payment({ - signer: transactionSigner, + signer: async (txnGroup, indexesToSign) => { + const encoded = txnGroup.map((txn) => encodeTransactionRaw(txn)) + const signed = await signTransactions(encoded, indexesToSign) + return signed.filter((s): s is Uint8Array => s !== null) + }, sender: activeAddress, receiver: receiverAddress, amount: algo(1), diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/AppCall.ts b/examples/p-py/projects/p-py-frontend/src/contracts/AppCall.ts new file mode 100644 index 0000000..c61e144 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/AppCall.ts @@ -0,0 +1,558 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"AppCall","structs":{},"methods":[{"name":"some_value","args":[],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvb3RoZXIucHk6NAogICAgLy8gY2xhc3MgQXBwQ2FsbChBUkM0Q29udHJhY3QpOgogICAgdHhuIE51bUFwcEFyZ3MKICAgIGJ6IG1haW5fX19hbGdvcHlfZGVmYXVsdF9jcmVhdGVANQogICAgcHVzaGJ5dGVzIDB4ZDM0NzllNjUgLy8gbWV0aG9kICJzb21lX3ZhbHVlKCl1aW50NjQiCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCBtYWluX3NvbWVfdmFsdWVfcm91dGVAMwogICAgZXJyCgptYWluX3NvbWVfdmFsdWVfcm91dGVAMzoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvb3RoZXIucHk6NQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICAmJgogICAgYXNzZXJ0CiAgICBiIHNvbWVfdmFsdWUKCm1haW5fX19hbGdvcHlfZGVmYXVsdF9jcmVhdGVANToKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICAhCiAgICAmJgogICAgcmV0dXJuCgoKLy8gdGVzdHMuYXJ0aWZhY3RzLkNyZWF0ZWRBcHBBc3NldC5vdGhlci5BcHBDYWxsLnNvbWVfdmFsdWVbcm91dGluZ10oKSAtPiB2b2lkOgpzb21lX3ZhbHVlOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9vdGhlci5weTo3CiAgICAvLyByZXR1cm4gR2xvYmFsLmdyb3VwX3NpemUgKiAoVHhuLmdyb3VwX2luZGV4ICsgMSkKICAgIGdsb2JhbCBHcm91cFNpemUKICAgIHR4biBHcm91cEluZGV4CiAgICBwdXNoaW50IDEKICAgICsKICAgICoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvb3RoZXIucHk6NQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIGl0b2IKICAgIHB1c2hieXRlcyAweDE1MWY3Yzc1CiAgICBzd2FwCiAgICBjb25jYXQKICAgIGxvZwogICAgcHVzaGludCAxCiAgICByZXR1cm4K","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CzEbQQAYgATTR55lNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEMyBDEWgQEICxaABBUffHVMULCBAUM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the AppCall contract + */ +export type AppCallArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'some_value()uint64': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'some_value()uint64': [] + } +} + +/** + * The return type for each method + */ +export type AppCallReturns = { + 'some_value()uint64': bigint +} + +/** + * Defines the types of available calls and state of the AppCall smart contract. + */ +export type AppCallTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'some_value()uint64' | 'some_value', { + argsObj: AppCallArgs['obj']['some_value()uint64'] + argsTuple: AppCallArgs['tuple']['some_value()uint64'] + returns: AppCallReturns['some_value()uint64'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type AppCallSignatures = keyof AppCallTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type AppCallNonVoidMethodSignatures = keyof AppCallTypes['methods'] extends infer T ? T extends keyof AppCallTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the AppCall smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = AppCallTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the AppCall smart contract to the method's return type + */ +export type MethodReturn = AppCallTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type AppCallCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type AppCallDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: AppCallCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the AppCall smart contract + */ +export abstract class AppCallParamsFactory { + /** + * Constructs a no op call for the some_value()uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static someValue(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'some_value()uint64' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the AppCall smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class AppCallFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `AppCallFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new AppCallClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new AppCallClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the AppCall smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: AppCallDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new AppCallClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the AppCall smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the AppCall smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the AppCall smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new AppCallClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the AppCall smart contract + */ +export class AppCallClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `AppCallClient` + * + * @param appClient An `AppClient` instance which has been created with the AppCall app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `AppCallClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `AppCallClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new AppCallClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `AppCallClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new AppCallClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the AppCall smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the AppCall smart contract using the `some_value()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + someValue: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(AppCallParamsFactory.someValue(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the AppCall smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the AppCall smart contract using the `some_value()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + someValue: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(AppCallParamsFactory.someValue(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the AppCall smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the AppCall smart contract using the `some_value()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + someValue: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(AppCallParamsFactory.someValue(params)) + return {...result, return: result.return as unknown as (undefined | AppCallReturns['some_value()uint64'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new AppCallClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current AppCall app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): AppCallComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a some_value()uint64 method call against the AppCall contract + */ + someValue(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.someValue(params))) + return this + }, + /** + * Add a clear state call to the AppCall contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as AppCallComposer + } +} +export type AppCallComposer = { + /** + * Calls the some_value()uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + someValue(params?: CallParams): AppCallComposer<[...TReturns, AppCallReturns['some_value()uint64'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the AppCall smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): AppCallComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): AppCallComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type AppCallComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/AppExpectingEffects.ts b/examples/p-py/projects/p-py-frontend/src/contracts/AppExpectingEffects.ts new file mode 100644 index 0000000..1a953ef --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/AppExpectingEffects.ts @@ -0,0 +1,630 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"AppExpectingEffects","structs":{},"methods":[{"name":"create_group","args":[{"type":"acfg","name":"asset_create"},{"type":"appl","name":"app_create"}],"returns":{"type":"(uint64,uint64)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"log_group","args":[{"type":"appl","name":"app_call"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[159],"errorMessage":"application log value is not the result of an ABI return"},{"pc":[96],"errorMessage":"expected app created"},{"pc":[81],"errorMessage":"expected asset created"},{"pc":[105],"errorMessage":"expected correct app id"},{"pc":[90],"errorMessage":"expected correct asset id"},{"pc":[139],"errorMessage":"expected correct method called"},{"pc":[145],"errorMessage":"expected logs"},{"pc":[65],"errorMessage":"transaction type is acfg"},{"pc":[75,126],"errorMessage":"transaction type is appl"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIGludGNibG9jayAxIDYKICAgIGJ5dGVjYmxvY2sgMHgxNTFmN2M3NQogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9jb250cmFjdC5weTo0CiAgICAvLyBjbGFzcyBBcHBFeHBlY3RpbmdFZmZlY3RzKEFSQzRDb250cmFjdCk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9fX2FsZ29weV9kZWZhdWx0X2NyZWF0ZUA5CiAgICB0eG4gT25Db21wbGV0aW9uCiAgICAhCiAgICBhc3NlcnQKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICBhc3NlcnQKICAgIHB1c2hieXRlc3MgMHg2ZDNhMDQzOSAweDYyYTBlZjYyIC8vIG1ldGhvZCAiY3JlYXRlX2dyb3VwKGFjZmcsYXBwbCkodWludDY0LHVpbnQ2NCkiLCBtZXRob2QgImxvZ19ncm91cChhcHBsKXZvaWQiCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCBjcmVhdGVfZ3JvdXAgbG9nX2dyb3VwCiAgICBlcnIKCm1haW5fX19hbGdvcHlfZGVmYXVsdF9jcmVhdGVAOToKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICAhCiAgICAmJgogICAgcmV0dXJuCgoKLy8gdGVzdHMuYXJ0aWZhY3RzLkNyZWF0ZWRBcHBBc3NldC5jb250cmFjdC5BcHBFeHBlY3RpbmdFZmZlY3RzLmNyZWF0ZV9ncm91cFtyb3V0aW5nXSgpIC0+IHZvaWQ6CmNyZWF0ZV9ncm91cDoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvY29udHJhY3QucHk6NQogICAgLy8gQGFyYzQuYWJpbWV0aG9kCiAgICB0eG4gR3JvdXBJbmRleAogICAgcHVzaGludCAyCiAgICAtCiAgICBkdXAKICAgIGd0eG5zIFR5cGVFbnVtCiAgICBwdXNoaW50IDMgLy8gYWNmZwogICAgPT0KICAgIGFzc2VydCAvLyB0cmFuc2FjdGlvbiB0eXBlIGlzIGFjZmcKICAgIHR4biBHcm91cEluZGV4CiAgICBpbnRjXzAgLy8gMQogICAgLQogICAgZHVwCiAgICBndHhucyBUeXBlRW51bQogICAgaW50Y18xIC8vIGFwcGwKICAgID09CiAgICBhc3NlcnQgLy8gdHJhbnNhY3Rpb24gdHlwZSBpcyBhcHBsCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L2NvbnRyYWN0LnB5OjExCiAgICAvLyBhc3NlcnQgYXNzZXRfY3JlYXRlLmNyZWF0ZWRfYXNzZXQuaWQsICJleHBlY3RlZCBhc3NldCBjcmVhdGVkIgogICAgZGlnIDEKICAgIGd0eG5zIENyZWF0ZWRBc3NldElECiAgICBkdXAKICAgIGFzc2VydCAvLyBleHBlY3RlZCBhc3NldCBjcmVhdGVkCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L2NvbnRyYWN0LnB5OjEzCiAgICAvLyBvcC5nYWlkKGFzc2V0X2NyZWF0ZS5ncm91cF9pbmRleCkgPT0gYXNzZXRfY3JlYXRlLmNyZWF0ZWRfYXNzZXQuaWQKICAgIHVuY292ZXIgMgogICAgZ3R4bnMgR3JvdXBJbmRleAogICAgZ2FpZHMKICAgIGRpZyAxCiAgICA9PQogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9jb250cmFjdC5weToxMi0xNAogICAgLy8gYXNzZXJ0ICgKICAgIC8vICAgICBvcC5nYWlkKGFzc2V0X2NyZWF0ZS5ncm91cF9pbmRleCkgPT0gYXNzZXRfY3JlYXRlLmNyZWF0ZWRfYXNzZXQuaWQKICAgIC8vICksICJleHBlY3RlZCBjb3JyZWN0IGFzc2V0IGlkIgogICAgYXNzZXJ0IC8vIGV4cGVjdGVkIGNvcnJlY3QgYXNzZXQgaWQKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvY29udHJhY3QucHk6MTUKICAgIC8vIGFzc2VydCBhcHBfY3JlYXRlLmNyZWF0ZWRfYXBwLmlkLCAiZXhwZWN0ZWQgYXBwIGNyZWF0ZWQiCiAgICBkaWcgMQogICAgZ3R4bnMgQ3JlYXRlZEFwcGxpY2F0aW9uSUQKICAgIGR1cAogICAgYXNzZXJ0IC8vIGV4cGVjdGVkIGFwcCBjcmVhdGVkCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L2NvbnRyYWN0LnB5OjE3CiAgICAvLyBvcC5nYWlkKGFwcF9jcmVhdGUuZ3JvdXBfaW5kZXgpID09IGFwcF9jcmVhdGUuY3JlYXRlZF9hcHAuaWQKICAgIHVuY292ZXIgMgogICAgZ3R4bnMgR3JvdXBJbmRleAogICAgZ2FpZHMKICAgIGRpZyAxCiAgICA9PQogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9jb250cmFjdC5weToxNi0xOAogICAgLy8gYXNzZXJ0ICgKICAgIC8vICAgICBvcC5nYWlkKGFwcF9jcmVhdGUuZ3JvdXBfaW5kZXgpID09IGFwcF9jcmVhdGUuY3JlYXRlZF9hcHAuaWQKICAgIC8vICksICJleHBlY3RlZCBjb3JyZWN0IGFwcCBpZCIKICAgIGFzc2VydCAvLyBleHBlY3RlZCBjb3JyZWN0IGFwcCBpZAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9jb250cmFjdC5weTo1CiAgICAvLyBAYXJjNC5hYmltZXRob2QKICAgIHN3YXAKICAgIGl0b2IKICAgIHN3YXAKICAgIGl0b2IKICAgIGNvbmNhdAogICAgYnl0ZWNfMCAvLyAweDE1MWY3Yzc1CiAgICBzd2FwCiAgICBjb25jYXQKICAgIGxvZwogICAgaW50Y18wIC8vIDEKICAgIHJldHVybgoKCi8vIHRlc3RzLmFydGlmYWN0cy5DcmVhdGVkQXBwQXNzZXQuY29udHJhY3QuQXBwRXhwZWN0aW5nRWZmZWN0cy5sb2dfZ3JvdXBbcm91dGluZ10oKSAtPiB2b2lkOgpsb2dfZ3JvdXA6CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L2NvbnRyYWN0LnB5OjIyCiAgICAvLyBAYXJjNC5hYmltZXRob2QKICAgIHR4biBHcm91cEluZGV4CiAgICBpbnRjXzAgLy8gMQogICAgLQogICAgZHVwCiAgICBndHhucyBUeXBlRW51bQogICAgaW50Y18xIC8vIGFwcGwKICAgID09CiAgICBhc3NlcnQgLy8gdHJhbnNhY3Rpb24gdHlwZSBpcyBhcHBsCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L2NvbnRyYWN0LnB5OjI0CiAgICAvLyBhc3NlcnQgYXBwX2NhbGwuYXBwX2FyZ3MoMCkgPT0gYXJjNC5hcmM0X3NpZ25hdHVyZSgKICAgIGR1cAogICAgcHVzaGludCAwCiAgICBndHhuc2FzIEFwcGxpY2F0aW9uQXJncwogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9jb250cmFjdC5weToyNC0yNgogICAgLy8gYXNzZXJ0IGFwcF9jYWxsLmFwcF9hcmdzKDApID09IGFyYzQuYXJjNF9zaWduYXR1cmUoCiAgICAvLyAgICAgInNvbWVfdmFsdWUoKXVpbnQ2NCIKICAgIC8vICksICJleHBlY3RlZCBjb3JyZWN0IG1ldGhvZCBjYWxsZWQiCiAgICBwdXNoYnl0ZXMgMHhkMzQ3OWU2NSAvLyBtZXRob2QgInNvbWVfdmFsdWUoKXVpbnQ2NCIKICAgID09CiAgICBhc3NlcnQgLy8gZXhwZWN0ZWQgY29ycmVjdCBtZXRob2QgY2FsbGVkCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L2NvbnRyYWN0LnB5OjI3CiAgICAvLyBhc3NlcnQgYXBwX2NhbGwubnVtX2xvZ3MgPT0gMSwgImV4cGVjdGVkIGxvZ3MiCiAgICBkdXAKICAgIGd0eG5zIE51bUxvZ3MKICAgIGludGNfMCAvLyAxCiAgICA9PQogICAgYXNzZXJ0IC8vIGV4cGVjdGVkIGxvZ3MKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvY29udHJhY3QucHk6MjkKICAgIC8vIGFyYzQuVUludDY0LmZyb21fbG9nKGFwcF9jYWxsLmxhc3RfbG9nKQogICAgZHVwCiAgICBndHhucyBMYXN0TG9nCiAgICBkdXAKICAgIGV4dHJhY3QgNCAwCiAgICBzd2FwCiAgICBleHRyYWN0IDAgNAogICAgYnl0ZWNfMCAvLyAweDE1MWY3Yzc1CiAgICA9PQogICAgYXNzZXJ0IC8vIGFwcGxpY2F0aW9uIGxvZyB2YWx1ZSBpcyBub3QgdGhlIHJlc3VsdCBvZiBhbiBBQkkgcmV0dXJuCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L2NvbnRyYWN0LnB5OjMwCiAgICAvLyA9PSAoYXBwX2NhbGwuZ3JvdXBfaW5kZXggKyAxKSAqIEdsb2JhbC5ncm91cF9zaXplCiAgICBzd2FwCiAgICBndHhucyBHcm91cEluZGV4CiAgICBpbnRjXzAgLy8gMQogICAgKwogICAgZ2xvYmFsIEdyb3VwU2l6ZQogICAgKgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9jb250cmFjdC5weToyOS0zMAogICAgLy8gYXJjNC5VSW50NjQuZnJvbV9sb2coYXBwX2NhbGwubGFzdF9sb2cpCiAgICAvLyA9PSAoYXBwX2NhbGwuZ3JvdXBfaW5kZXggKyAxKSAqIEdsb2JhbC5ncm91cF9zaXplCiAgICBpdG9iCiAgICBiPT0KICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvY29udHJhY3QucHk6MjgtMzEKICAgIC8vIGFzc2VydCAoCiAgICAvLyAgICAgYXJjNC5VSW50NjQuZnJvbV9sb2coYXBwX2NhbGwubGFzdF9sb2cpCiAgICAvLyAgICAgPT0gKGFwcF9jYWxsLmdyb3VwX2luZGV4ICsgMSkgKiBHbG9iYWwuZ3JvdXBfc2l6ZQogICAgLy8gKQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L2NvbnRyYWN0LnB5OjIyCiAgICAvLyBAYXJjNC5hYmltZXRob2QKICAgIGludGNfMCAvLyAxCiAgICByZXR1cm4K","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyACAQYmAQQVH3x1MRtBAB0xGRREMRhEggIEbToEOQRioO9iNhoAjgIACQBIADEZFDEYFBBDMRaBAglJOBCBAxJEMRYiCUk4ECMSREsBODxJRE8COBY9SwESREsBOD1JRE8COBY9SwESREwWTBZQKExQsCJDMRYiCUk4ECMSREmBAMIagATTR55lEkRJODsiEkRJOD5JVwQATFcABCgSREw4FiIIMgQLFqhEIkM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the AppExpectingEffects contract + */ +export type AppExpectingEffectsArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'create_group(acfg,appl)(uint64,uint64)': { + assetCreate?: AppMethodCallTransactionArgument + appCreate: AppMethodCallTransactionArgument + } + 'log_group(appl)void': { + appCall: AppMethodCallTransactionArgument + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'create_group(acfg,appl)(uint64,uint64)': [assetCreate: AppMethodCallTransactionArgument | undefined, appCreate: AppMethodCallTransactionArgument] + 'log_group(appl)void': [appCall: AppMethodCallTransactionArgument] + } +} + +/** + * The return type for each method + */ +export type AppExpectingEffectsReturns = { + 'create_group(acfg,appl)(uint64,uint64)': [bigint, bigint] + 'log_group(appl)void': void +} + +/** + * Defines the types of available calls and state of the AppExpectingEffects smart contract. + */ +export type AppExpectingEffectsTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'create_group(acfg,appl)(uint64,uint64)' | 'create_group', { + argsObj: AppExpectingEffectsArgs['obj']['create_group(acfg,appl)(uint64,uint64)'] + argsTuple: AppExpectingEffectsArgs['tuple']['create_group(acfg,appl)(uint64,uint64)'] + returns: AppExpectingEffectsReturns['create_group(acfg,appl)(uint64,uint64)'] + }> + & Record<'log_group(appl)void' | 'log_group', { + argsObj: AppExpectingEffectsArgs['obj']['log_group(appl)void'] + argsTuple: AppExpectingEffectsArgs['tuple']['log_group(appl)void'] + returns: AppExpectingEffectsReturns['log_group(appl)void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type AppExpectingEffectsSignatures = keyof AppExpectingEffectsTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type AppExpectingEffectsNonVoidMethodSignatures = keyof AppExpectingEffectsTypes['methods'] extends infer T ? T extends keyof AppExpectingEffectsTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the AppExpectingEffects smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = AppExpectingEffectsTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the AppExpectingEffects smart contract to the method's return type + */ +export type MethodReturn = AppExpectingEffectsTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type AppExpectingEffectsCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type AppExpectingEffectsDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: AppExpectingEffectsCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the AppExpectingEffects smart contract + */ +export abstract class AppExpectingEffectsParamsFactory { + /** + * Constructs a no op call for the create_group(acfg,appl)(uint64,uint64) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static createGroup(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'create_group(acfg,appl)(uint64,uint64)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.assetCreate, params.args.appCreate], + } + } + /** + * Constructs a no op call for the log_group(appl)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static logGroup(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'log_group(appl)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.appCall], + } + } +} + +/** + * A factory to create and deploy one or more instance of the AppExpectingEffects smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class AppExpectingEffectsFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `AppExpectingEffectsFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new AppExpectingEffectsClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new AppExpectingEffectsClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the AppExpectingEffects smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: AppExpectingEffectsDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new AppExpectingEffectsClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the AppExpectingEffects smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the AppExpectingEffects smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the AppExpectingEffects smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new AppExpectingEffectsClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the AppExpectingEffects smart contract + */ +export class AppExpectingEffectsClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `AppExpectingEffectsClient` + * + * @param appClient An `AppClient` instance which has been created with the AppExpectingEffects app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `AppExpectingEffectsClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `AppExpectingEffectsClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new AppExpectingEffectsClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `AppExpectingEffectsClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new AppExpectingEffectsClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the AppExpectingEffects smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the AppExpectingEffects smart contract using the `create_group(acfg,appl)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + createGroup: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(AppExpectingEffectsParamsFactory.createGroup(params)) + }, + + /** + * Makes a call to the AppExpectingEffects smart contract using the `log_group(appl)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + logGroup: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(AppExpectingEffectsParamsFactory.logGroup(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the AppExpectingEffects smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the AppExpectingEffects smart contract using the `create_group(acfg,appl)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + createGroup: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(AppExpectingEffectsParamsFactory.createGroup(params)) + }, + + /** + * Makes a call to the AppExpectingEffects smart contract using the `log_group(appl)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + logGroup: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(AppExpectingEffectsParamsFactory.logGroup(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the AppExpectingEffects smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the AppExpectingEffects smart contract using the `create_group(acfg,appl)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + createGroup: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(AppExpectingEffectsParamsFactory.createGroup(params)) + return {...result, return: result.return as unknown as (undefined | AppExpectingEffectsReturns['create_group(acfg,appl)(uint64,uint64)'])} + }, + + /** + * Makes a call to the AppExpectingEffects smart contract using the `log_group(appl)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + logGroup: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(AppExpectingEffectsParamsFactory.logGroup(params)) + return {...result, return: result.return as unknown as (undefined | AppExpectingEffectsReturns['log_group(appl)void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new AppExpectingEffectsClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current AppExpectingEffects app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): AppExpectingEffectsComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a create_group(acfg,appl)(uint64,uint64) method call against the AppExpectingEffects contract + */ + createGroup(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.createGroup(params))) + return this + }, + /** + * Add a log_group(appl)void method call against the AppExpectingEffects contract + */ + logGroup(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.logGroup(params))) + return this + }, + /** + * Add a clear state call to the AppExpectingEffects contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as AppExpectingEffectsComposer + } +} +export type AppExpectingEffectsComposer = { + /** + * Calls the create_group(acfg,appl)(uint64,uint64) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + createGroup(params?: CallParams): AppExpectingEffectsComposer<[...TReturns, AppExpectingEffectsReturns['create_group(acfg,appl)(uint64,uint64)'] | undefined]> + + /** + * Calls the log_group(appl)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + logGroup(params?: CallParams): AppExpectingEffectsComposer<[...TReturns, AppExpectingEffectsReturns['log_group(appl)void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the AppExpectingEffects smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): AppExpectingEffectsComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): AppExpectingEffectsComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type AppExpectingEffectsComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/Arc4InnerTxnsContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/Arc4InnerTxnsContract.ts new file mode 100644 index 0000000..afe3303 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/Arc4InnerTxnsContract.ts @@ -0,0 +1,556 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"Arc4InnerTxnsContract","structs":{},"methods":[{"name":"opt_in_dummy_asset","args":[{"type":"uint64","name":"asset"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CzEbQQAYgASrOcVaNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEM2GgEXsTIKshSyEYEEshCBALIBs4EBQw==","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the Arc4InnerTxnsContract contract + */ +export type Arc4InnerTxnsContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'opt_in_dummy_asset(uint64)void': { + asset: bigint | number + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'opt_in_dummy_asset(uint64)void': [asset: bigint | number] + } +} + +/** + * The return type for each method + */ +export type Arc4InnerTxnsContractReturns = { + 'opt_in_dummy_asset(uint64)void': void +} + +/** + * Defines the types of available calls and state of the Arc4InnerTxnsContract smart contract. + */ +export type Arc4InnerTxnsContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'opt_in_dummy_asset(uint64)void' | 'opt_in_dummy_asset', { + argsObj: Arc4InnerTxnsContractArgs['obj']['opt_in_dummy_asset(uint64)void'] + argsTuple: Arc4InnerTxnsContractArgs['tuple']['opt_in_dummy_asset(uint64)void'] + returns: Arc4InnerTxnsContractReturns['opt_in_dummy_asset(uint64)void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type Arc4InnerTxnsContractSignatures = keyof Arc4InnerTxnsContractTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the Arc4InnerTxnsContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = Arc4InnerTxnsContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the Arc4InnerTxnsContract smart contract to the method's return type + */ +export type MethodReturn = Arc4InnerTxnsContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type Arc4InnerTxnsContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type Arc4InnerTxnsContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: Arc4InnerTxnsContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the Arc4InnerTxnsContract smart contract + */ +export abstract class Arc4InnerTxnsContractParamsFactory { + /** + * Constructs a no op call for the opt_in_dummy_asset(uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static optInDummyAsset(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'opt_in_dummy_asset(uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.asset], + } + } +} + +/** + * A factory to create and deploy one or more instance of the Arc4InnerTxnsContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class Arc4InnerTxnsContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `Arc4InnerTxnsContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new Arc4InnerTxnsContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new Arc4InnerTxnsContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the Arc4InnerTxnsContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: Arc4InnerTxnsContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new Arc4InnerTxnsContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Arc4InnerTxnsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Arc4InnerTxnsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Arc4InnerTxnsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new Arc4InnerTxnsContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the Arc4InnerTxnsContract smart contract + */ +export class Arc4InnerTxnsContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `Arc4InnerTxnsContractClient` + * + * @param appClient An `AppClient` instance which has been created with the Arc4InnerTxnsContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `Arc4InnerTxnsContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `Arc4InnerTxnsContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new Arc4InnerTxnsContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `Arc4InnerTxnsContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new Arc4InnerTxnsContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the Arc4InnerTxnsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the Arc4InnerTxnsContract smart contract using the `opt_in_dummy_asset(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + optInDummyAsset: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4InnerTxnsContractParamsFactory.optInDummyAsset(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the Arc4InnerTxnsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the Arc4InnerTxnsContract smart contract using the `opt_in_dummy_asset(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + optInDummyAsset: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4InnerTxnsContractParamsFactory.optInDummyAsset(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the Arc4InnerTxnsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the Arc4InnerTxnsContract smart contract using the `opt_in_dummy_asset(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + optInDummyAsset: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4InnerTxnsContractParamsFactory.optInDummyAsset(params)) + return {...result, return: result.return as unknown as (undefined | Arc4InnerTxnsContractReturns['opt_in_dummy_asset(uint64)void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new Arc4InnerTxnsContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current Arc4InnerTxnsContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): Arc4InnerTxnsContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a opt_in_dummy_asset(uint64)void method call against the Arc4InnerTxnsContract contract + */ + optInDummyAsset(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.optInDummyAsset(params))) + return this + }, + /** + * Add a clear state call to the Arc4InnerTxnsContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as Arc4InnerTxnsContractComposer + } +} +export type Arc4InnerTxnsContractComposer = { + /** + * Calls the opt_in_dummy_asset(uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + optInDummyAsset(params?: CallParams): Arc4InnerTxnsContractComposer<[...TReturns, Arc4InnerTxnsContractReturns['opt_in_dummy_asset(uint64)void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the Arc4InnerTxnsContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): Arc4InnerTxnsContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): Arc4InnerTxnsContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type Arc4InnerTxnsContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/Arc4PrimitiveOpsContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/Arc4PrimitiveOpsContract.ts new file mode 100644 index 0000000..355f633 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/Arc4PrimitiveOpsContract.ts @@ -0,0 +1,3982 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"Arc4PrimitiveOpsContract","structs":{},"methods":[{"name":"verify_uintn_uintn_eq","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_uintn_eq","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_biguintn_eq","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_biguintn_eq","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_uintn_ne","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_uintn_ne","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_biguintn_ne","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_biguintn_ne","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_uintn_lt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_uintn_lt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_biguintn_lt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_biguintn_lt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_uintn_le","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_uintn_le","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_biguintn_le","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_biguintn_le","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_uintn_gt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_uintn_gt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_biguintn_gt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_biguintn_gt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_uintn_ge","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_uintn_ge","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_biguintn_ge","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_biguintn_ge","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_init","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint32"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_init","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint256"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_from_bytes","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint32"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_from_bytes","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint256"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn_from_log","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint32"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_from_log","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint256"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_as_uint64","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguintn_as_biguint","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint512"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn64_as_uint64","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uintn64_as_biguint","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint512"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ufixednxm_bytes","args":[{"type":"ufixed32x8","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bigufixednxm_bytes","args":[{"type":"ufixed256x16","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ufixednxm_from_bytes","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"ufixed32x8"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bigufixednxm_from_bytes","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"ufixed256x16"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ufixednxm_from_log","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"ufixed32x8"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bigufixednxm_from_log","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"ufixed256x16"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_init","args":[{"type":"string","name":"a"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_add","args":[{"type":"string","name":"a"},{"type":"string","name":"b"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_eq","args":[{"type":"string","name":"a"},{"type":"string","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_bytes","args":[{"type":"string","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_from_bytes","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_from_log","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bool_bytes","args":[{"type":"bool","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bool_from_bytes","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bool_from_log","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_emit","args":[{"type":"string","name":"a"},{"type":"uint512","name":"b"},{"type":"uint64","name":"c"},{"type":"byte[]","name":"d"},{"type":"uint64","name":"e"},{"type":"bool","name":"f"},{"type":"byte[]","name":"g"},{"type":"string","name":"h"},{"type":"uint64","name":"m"},{"type":"uint256","name":"n"},{"type":"ufixed32x8","name":"o"},{"type":"ufixed256x16","name":"p"},{"type":"bool","name":"q"},{"type":"byte[]","name":"r"},{"type":"byte[]","name":"s"},{"type":"byte[]","name":"t"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[{"name":"SwappedArc4","args":[{"type":"uint64","name":"m"},{"type":"uint256","name":"n"},{"type":"ufixed32x8","name":"o"},{"type":"ufixed256x16","name":"p"},{"type":"bool","name":"q"},{"type":"uint8[3]","name":"r"},{"type":"uint16[]","name":"s"},{"type":"(uint32,uint64,string)","name":"t"}]},{"name":"Swapped","args":[{"type":"string","name":"field1"},{"type":"uint512","name":"field2"},{"type":"uint64","name":"field3"},{"type":"byte[]","name":"field4"},{"type":"uint64","name":"field5"},{"type":"bool","name":"field6"},{"type":"byte[]","name":"field7"},{"type":"string","name":"field8"},{"type":"uint64","name":"field9"},{"type":"uint256","name":"field10"},{"type":"ufixed32x8","name":"field11"},{"type":"ufixed256x16","name":"field12"},{"type":"bool","name":"field13"},{"type":"uint8[3]","name":"field14"},{"type":"uint16[]","name":"field15"},{"type":"(uint32,uint64,string)","name":"field16"}]}],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[1579,1599,1788,1808,1933,1982],"errorMessage":"application log value is not the result of an ABI return"},{"pc":[1855],"errorMessage":"max array length exceeded"},{"pc":[411,424,457,468,503,514,549,562,595,608,641,652,687,698,733,746,779,792,825,836,871,882,917,930,963,976,1009,1020,1055,1066,1101,1114,1147,1160,1193,1204,1239,1250,1285,1298,1331,1344,1377,1388,1423,1434,1469,1482,1509,1531,1617,1626,1650,1659,1679,1699,1707],"errorMessage":"overflow"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 8 64 0
    bytecblock 0x151f7c75 0x00
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@57
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x96f14116 0xed666096 0x2ca0352b 0x85907d40 0x2cbec45b 0x07666fd9 0x370babd3 0x2b6b3ef0 0x339da97c 0x7898ed97 0x1f130cec 0xc748664e 0x7a460cb1 0xdcab1f01 0x97d9064d 0xce06c2a0 0xdcdbcee0 0x77a4b68d 0x4f540626 0x095aed41 0xe3b7e918 0x55337008 0x9bb1cd66 0x81484d9d 0x9a03df10 0xd3f0e44b 0x982db233 0xaffbdf0e 0x288af76e 0x8bd84a04 0x302b8a0a 0x337ae20b 0x6e259270 0x79e35f77 0x0f1574fe 0xb2cb13be 0xd059eea7 0x4cc4c157 0x3d17ac6e 0xf7f3d5fc 0xf8c8f8d5 0x43f7162a 0x42e09075 0xd956f575 0x6c0160df 0xa890150b 0x0b2f4c3f 0x9db9d327 0xe4d950a1 0xb605e80c // method "verify_uintn_uintn_eq(byte[],byte[])bool", method "verify_biguintn_uintn_eq(byte[],byte[])bool", method "verify_uintn_biguintn_eq(byte[],byte[])bool", method "verify_biguintn_biguintn_eq(byte[],byte[])bool", method "verify_uintn_uintn_ne(byte[],byte[])bool", method "verify_biguintn_uintn_ne(byte[],byte[])bool", method "verify_uintn_biguintn_ne(byte[],byte[])bool", method "verify_biguintn_biguintn_ne(byte[],byte[])bool", method "verify_uintn_uintn_lt(byte[],byte[])bool", method "verify_biguintn_uintn_lt(byte[],byte[])bool", method "verify_uintn_biguintn_lt(byte[],byte[])bool", method "verify_biguintn_biguintn_lt(byte[],byte[])bool", method "verify_uintn_uintn_le(byte[],byte[])bool", method "verify_biguintn_uintn_le(byte[],byte[])bool", method "verify_uintn_biguintn_le(byte[],byte[])bool", method "verify_biguintn_biguintn_le(byte[],byte[])bool", method "verify_uintn_uintn_gt(byte[],byte[])bool", method "verify_biguintn_uintn_gt(byte[],byte[])bool", method "verify_uintn_biguintn_gt(byte[],byte[])bool", method "verify_biguintn_biguintn_gt(byte[],byte[])bool", method "verify_uintn_uintn_ge(byte[],byte[])bool", method "verify_biguintn_uintn_ge(byte[],byte[])bool", method "verify_uintn_biguintn_ge(byte[],byte[])bool", method "verify_biguintn_biguintn_ge(byte[],byte[])bool", method "verify_uintn_init(byte[])uint32", method "verify_biguintn_init(byte[])uint256", method "verify_uintn_from_bytes(byte[])uint32", method "verify_biguintn_from_bytes(byte[])uint256", method "verify_uintn_from_log(byte[])uint32", method "verify_biguintn_from_log(byte[])uint256", method "verify_biguintn_as_uint64(byte[])uint64", method "verify_biguintn_as_biguint(byte[])uint512", method "verify_uintn64_as_uint64(byte[])uint64", method "verify_uintn64_as_biguint(byte[])uint512", method "verify_ufixednxm_bytes(ufixed32x8)byte[]", method "verify_bigufixednxm_bytes(ufixed256x16)byte[]", method "verify_ufixednxm_from_bytes(byte[])ufixed32x8", method "verify_bigufixednxm_from_bytes(byte[])ufixed256x16", method "verify_ufixednxm_from_log(byte[])ufixed32x8", method "verify_bigufixednxm_from_log(byte[])ufixed256x16", method "verify_string_init(string)string", method "verify_string_add(string,string)string", method "verify_string_eq(string,string)bool", method "verify_string_bytes(string)byte[]", method "verify_string_from_bytes(byte[])string", method "verify_string_from_log(byte[])string", method "verify_bool_bytes(bool)byte[]", method "verify_bool_from_bytes(byte[])bool", method "verify_bool_from_log(byte[])bool", method "verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void"
    txna ApplicationArgs 0
    match verify_uintn_uintn_eq verify_biguintn_uintn_eq verify_uintn_biguintn_eq verify_biguintn_biguintn_eq verify_uintn_uintn_ne verify_biguintn_uintn_ne verify_uintn_biguintn_ne verify_biguintn_biguintn_ne verify_uintn_uintn_lt verify_biguintn_uintn_lt verify_uintn_biguintn_lt verify_biguintn_biguintn_lt verify_uintn_uintn_le verify_biguintn_uintn_le verify_uintn_biguintn_le verify_biguintn_biguintn_le verify_uintn_uintn_gt verify_biguintn_uintn_gt verify_uintn_biguintn_gt verify_biguintn_biguintn_gt verify_uintn_uintn_ge verify_biguintn_uintn_ge verify_uintn_biguintn_ge verify_biguintn_biguintn_ge verify_uintn_init verify_biguintn_init verify_uintn_from_bytes verify_biguintn_from_bytes verify_uintn_from_log verify_biguintn_from_log verify_biguintn_as_uint64 verify_biguintn_as_biguint verify_uintn64_as_uint64 verify_uintn64_as_biguint verify_ufixednxm_bytes verify_bigufixednxm_bytes verify_ufixednxm_from_bytes verify_bigufixednxm_from_bytes verify_ufixednxm_from_log verify_bigufixednxm_from_log verify_string_init verify_string_add verify_string_eq verify_string_bytes verify_string_from_bytes verify_string_from_log verify_bool_bytes verify_bool_from_bytes verify_bool_from_log verify_emit
    err

main___algopy_default_create@57:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_eq[routing]() -> void:
verify_uintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:11
    // return arc4.UInt64(a_biguint) == arc4.UInt64(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_1 // 8
    <=
    assert // overflow
    cover 2
    b|
    b==
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_eq[routing]() -> void:
verify_biguintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:17
    // return arc4.UInt512(a_biguint) == arc4.UInt64(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    b==
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_eq[routing]() -> void:
verify_uintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:23
    // return arc4.UInt64(a_biguint) == arc4.UInt512(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    b==
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_eq[routing]() -> void:
verify_biguintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:29
    // return arc4.UInt512(a_biguint) == arc4.UInt512(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_2 // 64
    <=
    assert // overflow
    cover 2
    b|
    b==
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ne[routing]() -> void:
verify_uintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:35
    // return arc4.UInt64(a_biguint) != arc4.UInt64(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_1 // 8
    <=
    assert // overflow
    cover 2
    b|
    b!=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ne[routing]() -> void:
verify_biguintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:41
    // return arc4.UInt512(a_biguint) != arc4.UInt64(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    b!=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ne[routing]() -> void:
verify_uintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:47
    // return arc4.UInt64(a_biguint) != arc4.UInt512(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    b!=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ne[routing]() -> void:
verify_biguintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:53
    // return arc4.UInt512(a_biguint) != arc4.UInt512(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_2 // 64
    <=
    assert // overflow
    cover 2
    b|
    b!=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_lt[routing]() -> void:
verify_uintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:59
    // return arc4.UInt64(a_biguint) < arc4.UInt64(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_1 // 8
    <=
    assert // overflow
    cover 2
    b|
    b<
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_lt[routing]() -> void:
verify_biguintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:65
    // return arc4.UInt512(a_biguint) < arc4.UInt64(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    b<
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_lt[routing]() -> void:
verify_uintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:71
    // return arc4.UInt64(a_biguint) < arc4.UInt512(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    b<
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_lt[routing]() -> void:
verify_biguintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:77
    // return arc4.UInt512(a_biguint) < arc4.UInt512(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_2 // 64
    <=
    assert // overflow
    cover 2
    b|
    b<
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_le[routing]() -> void:
verify_uintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:83
    // return arc4.UInt64(a_biguint) <= arc4.UInt64(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_1 // 8
    <=
    assert // overflow
    cover 2
    b|
    b<=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_le[routing]() -> void:
verify_biguintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:89
    // return arc4.UInt512(a_biguint) <= arc4.UInt64(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    b<=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_le[routing]() -> void:
verify_uintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:95
    // return arc4.UInt64(a_biguint) <= arc4.UInt512(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    b<=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_le[routing]() -> void:
verify_biguintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:101
    // return arc4.UInt512(a_biguint) <= arc4.UInt512(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_2 // 64
    <=
    assert // overflow
    cover 2
    b|
    b<=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_gt[routing]() -> void:
verify_uintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:107
    // return arc4.UInt64(a_biguint) > arc4.UInt64(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_1 // 8
    <=
    assert // overflow
    cover 2
    b|
    b>
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_gt[routing]() -> void:
verify_biguintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:113
    // return arc4.UInt512(a_biguint) > arc4.UInt64(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    b>
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_gt[routing]() -> void:
verify_uintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:119
    // return arc4.UInt64(a_biguint) > arc4.UInt512(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    b>
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_gt[routing]() -> void:
verify_biguintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:125
    // return arc4.UInt512(a_biguint) > arc4.UInt512(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_2 // 64
    <=
    assert // overflow
    cover 2
    b|
    b>
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ge[routing]() -> void:
verify_uintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:131
    // return arc4.UInt64(a_biguint) >= arc4.UInt64(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_1 // 8
    <=
    assert // overflow
    cover 2
    b|
    b>=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ge[routing]() -> void:
verify_biguintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:137
    // return arc4.UInt512(a_biguint) >= arc4.UInt64(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    b>=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ge[routing]() -> void:
verify_uintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:143
    // return arc4.UInt64(a_biguint) >= arc4.UInt512(b_biguint)
    dig 1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    uncover 2
    b|
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    b|
    b>=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ge[routing]() -> void:
verify_biguintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:149
    // return arc4.UInt512(a_biguint) >= arc4.UInt512(b_biguint)
    dig 1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    uncover 2
    dig 1
    b|
    dig 2
    len
    intc_2 // 64
    <=
    assert // overflow
    cover 2
    b|
    b>=
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_init[routing]() -> void:
verify_uintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:154
    // return arc4.UInt32(a_biguint)
    dup
    len
    pushint 4
    <=
    assert // overflow
    pushint 4
    bzero
    b|
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_init[routing]() -> void:
verify_biguintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:159
    // return arc4.UInt256(a_biguint)
    dup
    len
    pushint 32
    <=
    assert // overflow
    pushint 32
    bzero
    b|
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_bytes[routing]() -> void:
verify_uintn_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_from_bytes[routing]() -> void:
verify_biguintn_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_log[routing]() -> void:
verify_uintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:171
    // return arc4.UInt32.from_log(a)
    dup
    extract 6 0
    swap
    extract 2 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_from_log[routing]() -> void:
verify_biguintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:175
    // return arc4.UInt256.from_log(a)
    dup
    extract 6 0
    swap
    extract 2 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_as_uint64[routing]() -> void:
verify_biguintn_as_uint64:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:180
    // return arc4.UInt256(a_biguint).as_uint64()
    dup
    len
    pushint 32
    <=
    assert // overflow
    pushint 32
    bzero
    b|
    dup
    bitlen
    intc_2 // 64
    <=
    assert // overflow
    dup
    len
    intc_1 // 8
    -
    intc_1 // 8
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    extract3
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_as_biguint[routing]() -> void:
verify_biguintn_as_biguint:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:182
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:185
    // return arc4.UInt256(a_biguint).as_biguint()
    dup
    len
    pushint 32
    <=
    assert // overflow
    pushint 32
    bzero
    b|
    // tests/artifacts/Arc4PrimitiveOps/contract.py:182
    // @arc4.abimethod()
    dup
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    b|
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn64_as_uint64[routing]() -> void:
verify_uintn64_as_uint64:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:187
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:190
    // return arc4.UInt64(a_biguint).as_uint64()
    dup
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    b|
    // tests/artifacts/Arc4PrimitiveOps/contract.py:187
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn64_as_biguint[routing]() -> void:
verify_uintn64_as_biguint:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:192
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // return arc4.UInt64(a_biguint).as_biguint()
    dup
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    b|
    // tests/artifacts/Arc4PrimitiveOps/contract.py:192
    // @arc4.abimethod()
    dup
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    b|
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_bytes[routing]() -> void:
verify_ufixednxm_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:197
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_bytes[routing]() -> void:
verify_bigufixednxm_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:203
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_bytes[routing]() -> void:
verify_ufixednxm_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:209
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_from_bytes[routing]() -> void:
verify_bigufixednxm_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:215
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_log[routing]() -> void:
verify_ufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:221
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:225
    // return arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]].from_log(a)
    dup
    extract 6 0
    swap
    extract 2 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    // tests/artifacts/Arc4PrimitiveOps/contract.py:221
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_from_log[routing]() -> void:
verify_bigufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:231
    // return arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]].from_log(a)
    dup
    extract 6 0
    swap
    extract 2 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_init[routing]() -> void:
verify_string_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:233
    // @arc4.abimethod
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:235
    // result = arc4.String(String("Hello, ") + a)
    pushbytes "Hello, "
    swap
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:233
    // @arc4.abimethod
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_add[routing]() -> void:
verify_string_add:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:238
    // @arc4.abimethod
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // result = a + b
    extract 2 0
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:238
    // @arc4.abimethod
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_eq[routing]() -> void:
verify_string_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:243
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:245
    // return a == b
    ==
    // tests/artifacts/Arc4PrimitiveOps/contract.py:243
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_bytes[routing]() -> void:
verify_string_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:247
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_from_bytes[routing]() -> void:
verify_string_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_from_log[routing]() -> void:
verify_string_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:256
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:258
    // return arc4.String.from_log(a)
    dup
    extract 6 0
    swap
    extract 2 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    // tests/artifacts/Arc4PrimitiveOps/contract.py:256
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_bytes[routing]() -> void:
verify_bool_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:260
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_bytes[routing]() -> void:
verify_bool_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:264
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_log[routing]() -> void:
verify_bool_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:268
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:270
    // return arc4.Bool.from_log(a)
    dup
    extract 6 0
    swap
    extract 2 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    // tests/artifacts/Arc4PrimitiveOps/contract.py:268
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_emit[routing]() -> void:
verify_emit:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:272
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    txna ApplicationArgs 5
    txna ApplicationArgs 6
    txna ApplicationArgs 7
    txna ApplicationArgs 8
    txna ApplicationArgs 9
    txna ApplicationArgs 10
    txna ApplicationArgs 11
    txna ApplicationArgs 12
    txna ApplicationArgs 13
    txna ApplicationArgs 14
    extract 2 0
    txna ApplicationArgs 15
    dup
    intc_3 // 0
    extract_uint16
    dig 1
    pushint 2
    extract_uint16
    substring3
    extract 2 0
    txna ApplicationArgs 15
    dup
    pushint 2
    extract_uint16
    dig 1
    len
    substring3
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:296
    // arc4.emit(SwappedArc4(m, n, o, p, q, arc4_r, arc4_s, arc4_t))
    dig 7
    dig 7
    concat
    dig 6
    concat
    dig 5
    concat
    dig 4
    concat
    dig 3
    concat
    pushbytes 0x0054
    concat
    dig 2
    len
    pushint 84
    dig 1
    +
    itob
    extract 6 2
    uncover 2
    swap
    concat
    dig 3
    concat
    dig 2
    concat
    pushbytes 0x66bb0333 // method "SwappedArc4(uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:297-315
    // arc4.emit(
    //     "Swapped",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    dig 16
    len
    pushint 173
    +
    pushbytes 0x00ad
    uncover 17
    concat
    uncover 16
    concat
    dig 1
    itob
    extract 6 2
    concat
    dig 15
    len
    uncover 2
    +
    swap
    uncover 14
    concat
    uncover 13
    concat
    dig 1
    itob
    extract 6 2
    concat
    dig 12
    len
    uncover 2
    +
    dup
    itob
    extract 6 2
    uncover 2
    swap
    concat
    dig 11
    len
    uncover 2
    +
    swap
    uncover 10
    concat
    uncover 9
    concat
    uncover 8
    concat
    uncover 7
    concat
    uncover 6
    concat
    uncover 5
    concat
    dig 1
    itob
    extract 6 2
    concat
    swap
    uncover 2
    +
    itob
    extract 6 2
    concat
    uncover 6
    concat
    uncover 5
    concat
    uncover 4
    concat
    uncover 3
    concat
    uncover 2
    concat
    swap
    concat
    pushbytes 0xec3319bb // method "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    dup
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:316-334
    // arc4.emit(
    //     "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:272
    // @arc4.abimethod()
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"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","clear":"C4EBQw=="},"events":[{"name":"SwappedArc4","args":[{"type":"uint64","name":"m"},{"type":"uint256","name":"n"},{"type":"ufixed32x8","name":"o"},{"type":"ufixed256x16","name":"p"},{"type":"bool","name":"q"},{"type":"uint8[3]","name":"r"},{"type":"uint16[]","name":"s"},{"type":"(uint32,uint64,string)","name":"t"}]},{"name":"Swapped","args":[{"type":"string","name":"field1"},{"type":"uint512","name":"field2"},{"type":"uint64","name":"field3"},{"type":"byte[]","name":"field4"},{"type":"uint64","name":"field5"},{"type":"bool","name":"field6"},{"type":"byte[]","name":"field7"},{"type":"string","name":"field8"},{"type":"uint64","name":"field9"},{"type":"uint256","name":"field10"},{"type":"ufixed32x8","name":"field11"},{"type":"ufixed256x16","name":"field12"},{"type":"bool","name":"field13"},{"type":"uint8[3]","name":"field14"},{"type":"uint16[]","name":"field15"},{"type":"(uint32,uint64,string)","name":"field16"}]}],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the Arc4PrimitiveOpsContract contract + */ +export type Arc4PrimitiveOpsContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_uintn_uintn_eq(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_uintn_eq(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_biguintn_eq(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_biguintn_eq(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_uintn_ne(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_uintn_ne(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_biguintn_ne(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_biguintn_ne(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_uintn_lt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_uintn_lt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_biguintn_lt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_biguintn_lt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_uintn_le(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_uintn_le(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_biguintn_le(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_biguintn_le(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_uintn_gt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_uintn_gt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_biguintn_gt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_biguintn_gt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_uintn_ge(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_uintn_ge(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_biguintn_ge(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguintn_biguintn_ge(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_uintn_init(byte[])uint32': { + a: Uint8Array + } + 'verify_biguintn_init(byte[])uint256': { + a: Uint8Array + } + 'verify_uintn_from_bytes(byte[])uint32': { + a: Uint8Array + } + 'verify_biguintn_from_bytes(byte[])uint256': { + a: Uint8Array + } + 'verify_uintn_from_log(byte[])uint32': { + a: Uint8Array + } + 'verify_biguintn_from_log(byte[])uint256': { + a: Uint8Array + } + 'verify_biguintn_as_uint64(byte[])uint64': { + a: Uint8Array + } + 'verify_biguintn_as_biguint(byte[])uint512': { + a: Uint8Array + } + 'verify_uintn64_as_uint64(byte[])uint64': { + a: Uint8Array + } + 'verify_uintn64_as_biguint(byte[])uint512': { + a: Uint8Array + } + 'verify_ufixednxm_bytes(ufixed32x8)byte[]': { + a: number + } + 'verify_bigufixednxm_bytes(ufixed256x16)byte[]': { + a: number + } + 'verify_ufixednxm_from_bytes(byte[])ufixed32x8': { + a: Uint8Array + } + 'verify_bigufixednxm_from_bytes(byte[])ufixed256x16': { + a: Uint8Array + } + 'verify_ufixednxm_from_log(byte[])ufixed32x8': { + a: Uint8Array + } + 'verify_bigufixednxm_from_log(byte[])ufixed256x16': { + a: Uint8Array + } + 'verify_string_init(string)string': { + a: string + } + 'verify_string_add(string,string)string': { + a: string + b: string + } + 'verify_string_eq(string,string)bool': { + a: string + b: string + } + 'verify_string_bytes(string)byte[]': { + a: string + } + 'verify_string_from_bytes(byte[])string': { + a: Uint8Array + } + 'verify_string_from_log(byte[])string': { + a: Uint8Array + } + 'verify_bool_bytes(bool)byte[]': { + a: boolean + } + 'verify_bool_from_bytes(byte[])bool': { + a: Uint8Array + } + 'verify_bool_from_log(byte[])bool': { + a: Uint8Array + } + 'verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void': { + a: string + b: bigint | number + c: bigint | number + d: Uint8Array + e: bigint | number + f: boolean + g: Uint8Array + h: string + m: bigint | number + n: bigint | number + o: number + p: number + q: boolean + r: Uint8Array + s: Uint8Array + t: Uint8Array + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_uintn_uintn_eq(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_uintn_eq(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_biguintn_eq(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_biguintn_eq(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_uintn_ne(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_uintn_ne(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_biguintn_ne(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_biguintn_ne(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_uintn_lt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_uintn_lt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_biguintn_lt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_biguintn_lt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_uintn_le(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_uintn_le(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_biguintn_le(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_biguintn_le(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_uintn_gt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_uintn_gt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_biguintn_gt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_biguintn_gt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_uintn_ge(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_uintn_ge(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_biguintn_ge(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguintn_biguintn_ge(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_uintn_init(byte[])uint32': [a: Uint8Array] + 'verify_biguintn_init(byte[])uint256': [a: Uint8Array] + 'verify_uintn_from_bytes(byte[])uint32': [a: Uint8Array] + 'verify_biguintn_from_bytes(byte[])uint256': [a: Uint8Array] + 'verify_uintn_from_log(byte[])uint32': [a: Uint8Array] + 'verify_biguintn_from_log(byte[])uint256': [a: Uint8Array] + 'verify_biguintn_as_uint64(byte[])uint64': [a: Uint8Array] + 'verify_biguintn_as_biguint(byte[])uint512': [a: Uint8Array] + 'verify_uintn64_as_uint64(byte[])uint64': [a: Uint8Array] + 'verify_uintn64_as_biguint(byte[])uint512': [a: Uint8Array] + 'verify_ufixednxm_bytes(ufixed32x8)byte[]': [a: number] + 'verify_bigufixednxm_bytes(ufixed256x16)byte[]': [a: number] + 'verify_ufixednxm_from_bytes(byte[])ufixed32x8': [a: Uint8Array] + 'verify_bigufixednxm_from_bytes(byte[])ufixed256x16': [a: Uint8Array] + 'verify_ufixednxm_from_log(byte[])ufixed32x8': [a: Uint8Array] + 'verify_bigufixednxm_from_log(byte[])ufixed256x16': [a: Uint8Array] + 'verify_string_init(string)string': [a: string] + 'verify_string_add(string,string)string': [a: string, b: string] + 'verify_string_eq(string,string)bool': [a: string, b: string] + 'verify_string_bytes(string)byte[]': [a: string] + 'verify_string_from_bytes(byte[])string': [a: Uint8Array] + 'verify_string_from_log(byte[])string': [a: Uint8Array] + 'verify_bool_bytes(bool)byte[]': [a: boolean] + 'verify_bool_from_bytes(byte[])bool': [a: Uint8Array] + 'verify_bool_from_log(byte[])bool': [a: Uint8Array] + 'verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void': [a: string, b: bigint | number, c: bigint | number, d: Uint8Array, e: bigint | number, f: boolean, g: Uint8Array, h: string, m: bigint | number, n: bigint | number, o: number, p: number, q: boolean, r: Uint8Array, s: Uint8Array, t: Uint8Array] + } +} + +/** + * The return type for each method + */ +export type Arc4PrimitiveOpsContractReturns = { + 'verify_uintn_uintn_eq(byte[],byte[])bool': boolean + 'verify_biguintn_uintn_eq(byte[],byte[])bool': boolean + 'verify_uintn_biguintn_eq(byte[],byte[])bool': boolean + 'verify_biguintn_biguintn_eq(byte[],byte[])bool': boolean + 'verify_uintn_uintn_ne(byte[],byte[])bool': boolean + 'verify_biguintn_uintn_ne(byte[],byte[])bool': boolean + 'verify_uintn_biguintn_ne(byte[],byte[])bool': boolean + 'verify_biguintn_biguintn_ne(byte[],byte[])bool': boolean + 'verify_uintn_uintn_lt(byte[],byte[])bool': boolean + 'verify_biguintn_uintn_lt(byte[],byte[])bool': boolean + 'verify_uintn_biguintn_lt(byte[],byte[])bool': boolean + 'verify_biguintn_biguintn_lt(byte[],byte[])bool': boolean + 'verify_uintn_uintn_le(byte[],byte[])bool': boolean + 'verify_biguintn_uintn_le(byte[],byte[])bool': boolean + 'verify_uintn_biguintn_le(byte[],byte[])bool': boolean + 'verify_biguintn_biguintn_le(byte[],byte[])bool': boolean + 'verify_uintn_uintn_gt(byte[],byte[])bool': boolean + 'verify_biguintn_uintn_gt(byte[],byte[])bool': boolean + 'verify_uintn_biguintn_gt(byte[],byte[])bool': boolean + 'verify_biguintn_biguintn_gt(byte[],byte[])bool': boolean + 'verify_uintn_uintn_ge(byte[],byte[])bool': boolean + 'verify_biguintn_uintn_ge(byte[],byte[])bool': boolean + 'verify_uintn_biguintn_ge(byte[],byte[])bool': boolean + 'verify_biguintn_biguintn_ge(byte[],byte[])bool': boolean + 'verify_uintn_init(byte[])uint32': number + 'verify_biguintn_init(byte[])uint256': bigint + 'verify_uintn_from_bytes(byte[])uint32': number + 'verify_biguintn_from_bytes(byte[])uint256': bigint + 'verify_uintn_from_log(byte[])uint32': number + 'verify_biguintn_from_log(byte[])uint256': bigint + 'verify_biguintn_as_uint64(byte[])uint64': bigint + 'verify_biguintn_as_biguint(byte[])uint512': bigint + 'verify_uintn64_as_uint64(byte[])uint64': bigint + 'verify_uintn64_as_biguint(byte[])uint512': bigint + 'verify_ufixednxm_bytes(ufixed32x8)byte[]': Uint8Array + 'verify_bigufixednxm_bytes(ufixed256x16)byte[]': Uint8Array + 'verify_ufixednxm_from_bytes(byte[])ufixed32x8': number + 'verify_bigufixednxm_from_bytes(byte[])ufixed256x16': number + 'verify_ufixednxm_from_log(byte[])ufixed32x8': number + 'verify_bigufixednxm_from_log(byte[])ufixed256x16': number + 'verify_string_init(string)string': string + 'verify_string_add(string,string)string': string + 'verify_string_eq(string,string)bool': boolean + 'verify_string_bytes(string)byte[]': Uint8Array + 'verify_string_from_bytes(byte[])string': string + 'verify_string_from_log(byte[])string': string + 'verify_bool_bytes(bool)byte[]': Uint8Array + 'verify_bool_from_bytes(byte[])bool': boolean + 'verify_bool_from_log(byte[])bool': boolean + 'verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void': void +} + +/** + * Defines the types of available calls and state of the Arc4PrimitiveOpsContract smart contract. + */ +export type Arc4PrimitiveOpsContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_uintn_uintn_eq(byte[],byte[])bool' | 'verify_uintn_uintn_eq', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_uintn_eq(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_uintn_eq(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_eq(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_uintn_eq(byte[],byte[])bool' | 'verify_biguintn_uintn_eq', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_uintn_eq(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_uintn_eq(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_eq(byte[],byte[])bool'] + }> + & Record<'verify_uintn_biguintn_eq(byte[],byte[])bool' | 'verify_uintn_biguintn_eq', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_biguintn_eq(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_biguintn_eq(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_eq(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_biguintn_eq(byte[],byte[])bool' | 'verify_biguintn_biguintn_eq', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_biguintn_eq(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_biguintn_eq(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_eq(byte[],byte[])bool'] + }> + & Record<'verify_uintn_uintn_ne(byte[],byte[])bool' | 'verify_uintn_uintn_ne', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_uintn_ne(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_uintn_ne(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_ne(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_uintn_ne(byte[],byte[])bool' | 'verify_biguintn_uintn_ne', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_uintn_ne(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_uintn_ne(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_ne(byte[],byte[])bool'] + }> + & Record<'verify_uintn_biguintn_ne(byte[],byte[])bool' | 'verify_uintn_biguintn_ne', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_biguintn_ne(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_biguintn_ne(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_ne(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_biguintn_ne(byte[],byte[])bool' | 'verify_biguintn_biguintn_ne', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_biguintn_ne(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_biguintn_ne(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_ne(byte[],byte[])bool'] + }> + & Record<'verify_uintn_uintn_lt(byte[],byte[])bool' | 'verify_uintn_uintn_lt', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_uintn_lt(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_uintn_lt(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_lt(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_uintn_lt(byte[],byte[])bool' | 'verify_biguintn_uintn_lt', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_uintn_lt(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_uintn_lt(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_lt(byte[],byte[])bool'] + }> + & Record<'verify_uintn_biguintn_lt(byte[],byte[])bool' | 'verify_uintn_biguintn_lt', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_biguintn_lt(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_biguintn_lt(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_lt(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_biguintn_lt(byte[],byte[])bool' | 'verify_biguintn_biguintn_lt', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_biguintn_lt(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_biguintn_lt(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_lt(byte[],byte[])bool'] + }> + & Record<'verify_uintn_uintn_le(byte[],byte[])bool' | 'verify_uintn_uintn_le', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_uintn_le(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_uintn_le(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_le(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_uintn_le(byte[],byte[])bool' | 'verify_biguintn_uintn_le', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_uintn_le(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_uintn_le(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_le(byte[],byte[])bool'] + }> + & Record<'verify_uintn_biguintn_le(byte[],byte[])bool' | 'verify_uintn_biguintn_le', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_biguintn_le(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_biguintn_le(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_le(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_biguintn_le(byte[],byte[])bool' | 'verify_biguintn_biguintn_le', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_biguintn_le(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_biguintn_le(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_le(byte[],byte[])bool'] + }> + & Record<'verify_uintn_uintn_gt(byte[],byte[])bool' | 'verify_uintn_uintn_gt', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_uintn_gt(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_uintn_gt(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_gt(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_uintn_gt(byte[],byte[])bool' | 'verify_biguintn_uintn_gt', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_uintn_gt(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_uintn_gt(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_gt(byte[],byte[])bool'] + }> + & Record<'verify_uintn_biguintn_gt(byte[],byte[])bool' | 'verify_uintn_biguintn_gt', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_biguintn_gt(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_biguintn_gt(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_gt(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_biguintn_gt(byte[],byte[])bool' | 'verify_biguintn_biguintn_gt', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_biguintn_gt(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_biguintn_gt(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_gt(byte[],byte[])bool'] + }> + & Record<'verify_uintn_uintn_ge(byte[],byte[])bool' | 'verify_uintn_uintn_ge', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_uintn_ge(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_uintn_ge(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_ge(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_uintn_ge(byte[],byte[])bool' | 'verify_biguintn_uintn_ge', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_uintn_ge(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_uintn_ge(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_ge(byte[],byte[])bool'] + }> + & Record<'verify_uintn_biguintn_ge(byte[],byte[])bool' | 'verify_uintn_biguintn_ge', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_biguintn_ge(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_biguintn_ge(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_ge(byte[],byte[])bool'] + }> + & Record<'verify_biguintn_biguintn_ge(byte[],byte[])bool' | 'verify_biguintn_biguintn_ge', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_biguintn_ge(byte[],byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_biguintn_ge(byte[],byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_ge(byte[],byte[])bool'] + }> + & Record<'verify_uintn_init(byte[])uint32' | 'verify_uintn_init', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_init(byte[])uint32'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_init(byte[])uint32'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_init(byte[])uint32'] + }> + & Record<'verify_biguintn_init(byte[])uint256' | 'verify_biguintn_init', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_init(byte[])uint256'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_init(byte[])uint256'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_init(byte[])uint256'] + }> + & Record<'verify_uintn_from_bytes(byte[])uint32' | 'verify_uintn_from_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_from_bytes(byte[])uint32'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_from_bytes(byte[])uint32'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_from_bytes(byte[])uint32'] + }> + & Record<'verify_biguintn_from_bytes(byte[])uint256' | 'verify_biguintn_from_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_from_bytes(byte[])uint256'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_from_bytes(byte[])uint256'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_from_bytes(byte[])uint256'] + }> + & Record<'verify_uintn_from_log(byte[])uint32' | 'verify_uintn_from_log', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn_from_log(byte[])uint32'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn_from_log(byte[])uint32'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn_from_log(byte[])uint32'] + }> + & Record<'verify_biguintn_from_log(byte[])uint256' | 'verify_biguintn_from_log', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_from_log(byte[])uint256'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_from_log(byte[])uint256'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_from_log(byte[])uint256'] + }> + & Record<'verify_biguintn_as_uint64(byte[])uint64' | 'verify_biguintn_as_uint64', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_as_uint64(byte[])uint64'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_as_uint64(byte[])uint64'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_as_uint64(byte[])uint64'] + }> + & Record<'verify_biguintn_as_biguint(byte[])uint512' | 'verify_biguintn_as_biguint', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_biguintn_as_biguint(byte[])uint512'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_biguintn_as_biguint(byte[])uint512'] + returns: Arc4PrimitiveOpsContractReturns['verify_biguintn_as_biguint(byte[])uint512'] + }> + & Record<'verify_uintn64_as_uint64(byte[])uint64' | 'verify_uintn64_as_uint64', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn64_as_uint64(byte[])uint64'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn64_as_uint64(byte[])uint64'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn64_as_uint64(byte[])uint64'] + }> + & Record<'verify_uintn64_as_biguint(byte[])uint512' | 'verify_uintn64_as_biguint', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_uintn64_as_biguint(byte[])uint512'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_uintn64_as_biguint(byte[])uint512'] + returns: Arc4PrimitiveOpsContractReturns['verify_uintn64_as_biguint(byte[])uint512'] + }> + & Record<'verify_ufixednxm_bytes(ufixed32x8)byte[]' | 'verify_ufixednxm_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_ufixednxm_bytes(ufixed32x8)byte[]'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_ufixednxm_bytes(ufixed32x8)byte[]'] + returns: Arc4PrimitiveOpsContractReturns['verify_ufixednxm_bytes(ufixed32x8)byte[]'] + }> + & Record<'verify_bigufixednxm_bytes(ufixed256x16)byte[]' | 'verify_bigufixednxm_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_bigufixednxm_bytes(ufixed256x16)byte[]'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_bigufixednxm_bytes(ufixed256x16)byte[]'] + returns: Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_bytes(ufixed256x16)byte[]'] + }> + & Record<'verify_ufixednxm_from_bytes(byte[])ufixed32x8' | 'verify_ufixednxm_from_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_ufixednxm_from_bytes(byte[])ufixed32x8'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_ufixednxm_from_bytes(byte[])ufixed32x8'] + returns: Arc4PrimitiveOpsContractReturns['verify_ufixednxm_from_bytes(byte[])ufixed32x8'] + }> + & Record<'verify_bigufixednxm_from_bytes(byte[])ufixed256x16' | 'verify_bigufixednxm_from_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_bigufixednxm_from_bytes(byte[])ufixed256x16'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_bigufixednxm_from_bytes(byte[])ufixed256x16'] + returns: Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_from_bytes(byte[])ufixed256x16'] + }> + & Record<'verify_ufixednxm_from_log(byte[])ufixed32x8' | 'verify_ufixednxm_from_log', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_ufixednxm_from_log(byte[])ufixed32x8'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_ufixednxm_from_log(byte[])ufixed32x8'] + returns: Arc4PrimitiveOpsContractReturns['verify_ufixednxm_from_log(byte[])ufixed32x8'] + }> + & Record<'verify_bigufixednxm_from_log(byte[])ufixed256x16' | 'verify_bigufixednxm_from_log', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_bigufixednxm_from_log(byte[])ufixed256x16'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_bigufixednxm_from_log(byte[])ufixed256x16'] + returns: Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_from_log(byte[])ufixed256x16'] + }> + & Record<'verify_string_init(string)string' | 'verify_string_init', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_string_init(string)string'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_string_init(string)string'] + returns: Arc4PrimitiveOpsContractReturns['verify_string_init(string)string'] + }> + & Record<'verify_string_add(string,string)string' | 'verify_string_add', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_string_add(string,string)string'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_string_add(string,string)string'] + returns: Arc4PrimitiveOpsContractReturns['verify_string_add(string,string)string'] + }> + & Record<'verify_string_eq(string,string)bool' | 'verify_string_eq', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_string_eq(string,string)bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_string_eq(string,string)bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_string_eq(string,string)bool'] + }> + & Record<'verify_string_bytes(string)byte[]' | 'verify_string_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_string_bytes(string)byte[]'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_string_bytes(string)byte[]'] + returns: Arc4PrimitiveOpsContractReturns['verify_string_bytes(string)byte[]'] + }> + & Record<'verify_string_from_bytes(byte[])string' | 'verify_string_from_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_string_from_bytes(byte[])string'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_string_from_bytes(byte[])string'] + returns: Arc4PrimitiveOpsContractReturns['verify_string_from_bytes(byte[])string'] + }> + & Record<'verify_string_from_log(byte[])string' | 'verify_string_from_log', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_string_from_log(byte[])string'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_string_from_log(byte[])string'] + returns: Arc4PrimitiveOpsContractReturns['verify_string_from_log(byte[])string'] + }> + & Record<'verify_bool_bytes(bool)byte[]' | 'verify_bool_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_bool_bytes(bool)byte[]'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_bool_bytes(bool)byte[]'] + returns: Arc4PrimitiveOpsContractReturns['verify_bool_bytes(bool)byte[]'] + }> + & Record<'verify_bool_from_bytes(byte[])bool' | 'verify_bool_from_bytes', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_bool_from_bytes(byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_bool_from_bytes(byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_bool_from_bytes(byte[])bool'] + }> + & Record<'verify_bool_from_log(byte[])bool' | 'verify_bool_from_log', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_bool_from_log(byte[])bool'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_bool_from_log(byte[])bool'] + returns: Arc4PrimitiveOpsContractReturns['verify_bool_from_log(byte[])bool'] + }> + & Record<'verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void' | 'verify_emit', { + argsObj: Arc4PrimitiveOpsContractArgs['obj']['verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void'] + argsTuple: Arc4PrimitiveOpsContractArgs['tuple']['verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void'] + returns: Arc4PrimitiveOpsContractReturns['verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type Arc4PrimitiveOpsContractSignatures = keyof Arc4PrimitiveOpsContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type Arc4PrimitiveOpsContractNonVoidMethodSignatures = keyof Arc4PrimitiveOpsContractTypes['methods'] extends infer T ? T extends keyof Arc4PrimitiveOpsContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the Arc4PrimitiveOpsContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = Arc4PrimitiveOpsContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the Arc4PrimitiveOpsContract smart contract to the method's return type + */ +export type MethodReturn = Arc4PrimitiveOpsContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type Arc4PrimitiveOpsContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type Arc4PrimitiveOpsContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: Arc4PrimitiveOpsContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the Arc4PrimitiveOpsContract smart contract + */ +export abstract class Arc4PrimitiveOpsContractParamsFactory { + /** + * Constructs a no op call for the verify_uintn_uintn_eq(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnUintnEq(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_uintn_eq(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_uintn_eq(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnUintnEq(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_uintn_eq(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_biguintn_eq(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnBiguintnEq(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_biguintn_eq(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_biguintn_eq(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnBiguintnEq(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_biguintn_eq(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_uintn_ne(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnUintnNe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_uintn_ne(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_uintn_ne(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnUintnNe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_uintn_ne(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_biguintn_ne(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnBiguintnNe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_biguintn_ne(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_biguintn_ne(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnBiguintnNe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_biguintn_ne(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_uintn_lt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnUintnLt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_uintn_lt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_uintn_lt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnUintnLt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_uintn_lt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_biguintn_lt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnBiguintnLt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_biguintn_lt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_biguintn_lt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnBiguintnLt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_biguintn_lt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_uintn_le(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnUintnLe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_uintn_le(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_uintn_le(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnUintnLe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_uintn_le(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_biguintn_le(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnBiguintnLe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_biguintn_le(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_biguintn_le(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnBiguintnLe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_biguintn_le(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_uintn_gt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnUintnGt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_uintn_gt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_uintn_gt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnUintnGt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_uintn_gt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_biguintn_gt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnBiguintnGt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_biguintn_gt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_biguintn_gt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnBiguintnGt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_biguintn_gt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_uintn_ge(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnUintnGe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_uintn_ge(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_uintn_ge(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnUintnGe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_uintn_ge(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_biguintn_ge(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnBiguintnGe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_biguintn_ge(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguintn_biguintn_ge(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnBiguintnGe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_biguintn_ge(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uintn_init(byte[])uint32 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_init(byte[])uint32' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_biguintn_init(byte[])uint256 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_init(byte[])uint256' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_uintn_from_bytes(byte[])uint32 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnFromBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_from_bytes(byte[])uint32' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_biguintn_from_bytes(byte[])uint256 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnFromBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_from_bytes(byte[])uint256' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_uintn_from_log(byte[])uint32 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintnFromLog(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn_from_log(byte[])uint32' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_biguintn_from_log(byte[])uint256 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnFromLog(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_from_log(byte[])uint256' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_biguintn_as_uint64(byte[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnAsUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_as_uint64(byte[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_biguintn_as_biguint(byte[])uint512 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintnAsBiguint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguintn_as_biguint(byte[])uint512' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_uintn64_as_uint64(byte[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintn64AsUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn64_as_uint64(byte[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_uintn64_as_biguint(byte[])uint512 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUintn64AsBiguint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uintn64_as_biguint(byte[])uint512' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_ufixednxm_bytes(ufixed32x8)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUfixednxmBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ufixednxm_bytes(ufixed32x8)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bigufixednxm_bytes(ufixed256x16)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBigufixednxmBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bigufixednxm_bytes(ufixed256x16)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_ufixednxm_from_bytes(byte[])ufixed32x8 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUfixednxmFromBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ufixednxm_from_bytes(byte[])ufixed32x8' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bigufixednxm_from_bytes(byte[])ufixed256x16 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBigufixednxmFromBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bigufixednxm_from_bytes(byte[])ufixed256x16' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_ufixednxm_from_log(byte[])ufixed32x8 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUfixednxmFromLog(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ufixednxm_from_log(byte[])ufixed32x8' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bigufixednxm_from_log(byte[])ufixed256x16 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBigufixednxmFromLog(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bigufixednxm_from_log(byte[])ufixed256x16' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_string_init(string)string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_init(string)string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_string_add(string,string)string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringAdd(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_add(string,string)string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_string_eq(string,string)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringEq(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_eq(string,string)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_string_bytes(string)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_bytes(string)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_string_from_bytes(byte[])string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringFromBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_from_bytes(byte[])string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_string_from_log(byte[])string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringFromLog(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_from_log(byte[])string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bool_bytes(bool)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBoolBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bool_bytes(bool)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bool_from_bytes(byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBoolFromBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bool_from_bytes(byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bool_from_log(byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBoolFromLog(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bool_from_log(byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEmit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c, params.args.d, params.args.e, params.args.f, params.args.g, params.args.h, params.args.m, params.args.n, params.args.o, params.args.p, params.args.q, params.args.r, params.args.s, params.args.t], + } + } +} + +/** + * A factory to create and deploy one or more instance of the Arc4PrimitiveOpsContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class Arc4PrimitiveOpsContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `Arc4PrimitiveOpsContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new Arc4PrimitiveOpsContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new Arc4PrimitiveOpsContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the Arc4PrimitiveOpsContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: Arc4PrimitiveOpsContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new Arc4PrimitiveOpsContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Arc4PrimitiveOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Arc4PrimitiveOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Arc4PrimitiveOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new Arc4PrimitiveOpsContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the Arc4PrimitiveOpsContract smart contract + */ +export class Arc4PrimitiveOpsContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `Arc4PrimitiveOpsContractClient` + * + * @param appClient An `AppClient` instance which has been created with the Arc4PrimitiveOpsContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `Arc4PrimitiveOpsContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `Arc4PrimitiveOpsContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new Arc4PrimitiveOpsContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `Arc4PrimitiveOpsContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new Arc4PrimitiveOpsContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the Arc4PrimitiveOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnUintnEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnUintnEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnBiguintnEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnBiguintnEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnUintnNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnNe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnUintnNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnNe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnBiguintnNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnNe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnBiguintnNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnNe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnUintnLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnLt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnUintnLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnLt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnBiguintnLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnLt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnBiguintnLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnLt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnUintnLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnLe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnUintnLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnLe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnBiguintnLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnLe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnBiguintnLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnLe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnUintnGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnGt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnUintnGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnGt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnBiguintnGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnGt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnBiguintnGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnGt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnUintnGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnGe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnUintnGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnGe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnBiguintnGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnGe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnBiguintnGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnGe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_init(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnInit(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_init(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnInit(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_from_bytes(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_from_bytes(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_from_log(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintnFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_from_log(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_as_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnAsUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnAsUint64(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_as_biguint(byte[])uint512` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintnAsBiguint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnAsBiguint(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn64_as_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintn64AsUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintn64AsUint64(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn64_as_biguint(byte[])uint512` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUintn64AsBiguint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintn64AsBiguint(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_bytes(ufixed32x8)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUfixednxmBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_bytes(ufixed256x16)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBigufixednxmBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_from_bytes(byte[])ufixed32x8` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUfixednxmFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_from_bytes(byte[])ufixed256x16` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBigufixednxmFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_from_log(byte[])ufixed32x8` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUfixednxmFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_from_log(byte[])ufixed256x16` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBigufixednxmFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_init(string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringInit(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_add(string,string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringAdd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringAdd(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_eq(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_bytes(string)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_from_bytes(byte[])string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_from_log(byte[])string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_bytes(bool)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBoolBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_from_bytes(byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBoolFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_from_log(byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBoolFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEmit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(Arc4PrimitiveOpsContractParamsFactory.verifyEmit(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the Arc4PrimitiveOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnUintnEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnUintnEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnBiguintnEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnBiguintnEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnUintnNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnNe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnUintnNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnNe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnBiguintnNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnNe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnBiguintnNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnNe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnUintnLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnLt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnUintnLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnLt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnBiguintnLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnLt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnBiguintnLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnLt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnUintnLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnLe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnUintnLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnLe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnBiguintnLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnLe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnBiguintnLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnLe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnUintnGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnGt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnUintnGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnGt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnBiguintnGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnGt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnBiguintnGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnGt(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnUintnGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnGe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnUintnGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnGe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnBiguintnGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnGe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnBiguintnGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnGe(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_init(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnInit(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_init(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnInit(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_from_bytes(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_from_bytes(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_from_log(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintnFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_from_log(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_as_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnAsUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnAsUint64(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_as_biguint(byte[])uint512` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintnAsBiguint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnAsBiguint(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn64_as_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintn64AsUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintn64AsUint64(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn64_as_biguint(byte[])uint512` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUintn64AsBiguint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintn64AsBiguint(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_bytes(ufixed32x8)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUfixednxmBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_bytes(ufixed256x16)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBigufixednxmBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_from_bytes(byte[])ufixed32x8` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUfixednxmFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_from_bytes(byte[])ufixed256x16` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBigufixednxmFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_from_log(byte[])ufixed32x8` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUfixednxmFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_from_log(byte[])ufixed256x16` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBigufixednxmFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_init(string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringInit(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_add(string,string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringAdd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringAdd(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_eq(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringEq(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_bytes(string)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_from_bytes(byte[])string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_from_log(byte[])string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_bytes(bool)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBoolBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_from_bytes(byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBoolFromBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolFromBytes(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_from_log(byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBoolFromLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolFromLog(params)) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEmit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(Arc4PrimitiveOpsContractParamsFactory.verifyEmit(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the Arc4PrimitiveOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnUintnEq: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnEq(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_eq(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnUintnEq: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnEq(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_eq(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnBiguintnEq: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnEq(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_eq(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnBiguintnEq: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnEq(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_eq(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnUintnNe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnNe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_ne(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnUintnNe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnNe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_ne(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnBiguintnNe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnNe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_ne(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnBiguintnNe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnNe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_ne(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnUintnLt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnLt(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_lt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnUintnLt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnLt(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_lt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnBiguintnLt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnLt(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_lt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnBiguintnLt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnLt(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_lt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnUintnLe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnLe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_le(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnUintnLe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnLe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_le(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnBiguintnLe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnLe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_le(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnBiguintnLe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnLe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_le(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnUintnGt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnGt(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_gt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnUintnGt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnGt(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_gt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnBiguintnGt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnGt(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_gt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnBiguintnGt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnGt(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_gt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_uintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnUintnGe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnUintnGe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_ge(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_uintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnUintnGe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnUintnGe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_ge(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_biguintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnBiguintnGe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnBiguintnGe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_ge(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_biguintn_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnBiguintnGe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnBiguintnGe(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_ge(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_init(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnInit(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_init(byte[])uint32'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_init(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnInit(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_init(byte[])uint256'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_from_bytes(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnFromBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnFromBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_from_bytes(byte[])uint32'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_from_bytes(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnFromBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnFromBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_from_bytes(byte[])uint256'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn_from_log(byte[])uint32` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintnFromLog: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintnFromLog(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn_from_log(byte[])uint32'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_from_log(byte[])uint256` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnFromLog: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnFromLog(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_from_log(byte[])uint256'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_as_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnAsUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnAsUint64(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_as_uint64(byte[])uint64'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_biguintn_as_biguint(byte[])uint512` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintnAsBiguint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBiguintnAsBiguint(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_biguintn_as_biguint(byte[])uint512'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn64_as_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintn64AsUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintn64AsUint64(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn64_as_uint64(byte[])uint64'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_uintn64_as_biguint(byte[])uint512` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUintn64AsBiguint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUintn64AsBiguint(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_uintn64_as_biguint(byte[])uint512'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_bytes(ufixed32x8)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUfixednxmBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_ufixednxm_bytes(ufixed32x8)byte[]'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_bytes(ufixed256x16)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBigufixednxmBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_bytes(ufixed256x16)byte[]'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_from_bytes(byte[])ufixed32x8` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUfixednxmFromBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmFromBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_ufixednxm_from_bytes(byte[])ufixed32x8'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_from_bytes(byte[])ufixed256x16` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBigufixednxmFromBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmFromBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_from_bytes(byte[])ufixed256x16'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_ufixednxm_from_log(byte[])ufixed32x8` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUfixednxmFromLog: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyUfixednxmFromLog(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_ufixednxm_from_log(byte[])ufixed32x8'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bigufixednxm_from_log(byte[])ufixed256x16` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBigufixednxmFromLog: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBigufixednxmFromLog(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_from_log(byte[])ufixed256x16'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_init(string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringInit(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_string_init(string)string'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_add(string,string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringAdd: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringAdd(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_string_add(string,string)string'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_eq(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringEq: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringEq(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_string_eq(string,string)bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_bytes(string)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_string_bytes(string)byte[]'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_from_bytes(byte[])string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringFromBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringFromBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_string_from_bytes(byte[])string'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_string_from_log(byte[])string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringFromLog: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyStringFromLog(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_string_from_log(byte[])string'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_bytes(bool)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBoolBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_bool_bytes(bool)byte[]'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_from_bytes(byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBoolFromBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolFromBytes(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_bool_from_bytes(byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_bool_from_log(byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBoolFromLog: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyBoolFromLog(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_bool_from_log(byte[])bool'])} + }, + + /** + * Makes a call to the Arc4PrimitiveOpsContract smart contract using the `verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEmit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(Arc4PrimitiveOpsContractParamsFactory.verifyEmit(params)) + return {...result, return: result.return as unknown as (undefined | Arc4PrimitiveOpsContractReturns['verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new Arc4PrimitiveOpsContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current Arc4PrimitiveOpsContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): Arc4PrimitiveOpsContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_uintn_uintn_eq(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnUintnEq(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnUintnEq(params))) + return this + }, + /** + * Add a verify_biguintn_uintn_eq(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnUintnEq(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnUintnEq(params))) + return this + }, + /** + * Add a verify_uintn_biguintn_eq(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnBiguintnEq(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnBiguintnEq(params))) + return this + }, + /** + * Add a verify_biguintn_biguintn_eq(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnBiguintnEq(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnBiguintnEq(params))) + return this + }, + /** + * Add a verify_uintn_uintn_ne(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnUintnNe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnUintnNe(params))) + return this + }, + /** + * Add a verify_biguintn_uintn_ne(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnUintnNe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnUintnNe(params))) + return this + }, + /** + * Add a verify_uintn_biguintn_ne(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnBiguintnNe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnBiguintnNe(params))) + return this + }, + /** + * Add a verify_biguintn_biguintn_ne(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnBiguintnNe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnBiguintnNe(params))) + return this + }, + /** + * Add a verify_uintn_uintn_lt(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnUintnLt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnUintnLt(params))) + return this + }, + /** + * Add a verify_biguintn_uintn_lt(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnUintnLt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnUintnLt(params))) + return this + }, + /** + * Add a verify_uintn_biguintn_lt(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnBiguintnLt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnBiguintnLt(params))) + return this + }, + /** + * Add a verify_biguintn_biguintn_lt(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnBiguintnLt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnBiguintnLt(params))) + return this + }, + /** + * Add a verify_uintn_uintn_le(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnUintnLe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnUintnLe(params))) + return this + }, + /** + * Add a verify_biguintn_uintn_le(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnUintnLe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnUintnLe(params))) + return this + }, + /** + * Add a verify_uintn_biguintn_le(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnBiguintnLe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnBiguintnLe(params))) + return this + }, + /** + * Add a verify_biguintn_biguintn_le(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnBiguintnLe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnBiguintnLe(params))) + return this + }, + /** + * Add a verify_uintn_uintn_gt(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnUintnGt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnUintnGt(params))) + return this + }, + /** + * Add a verify_biguintn_uintn_gt(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnUintnGt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnUintnGt(params))) + return this + }, + /** + * Add a verify_uintn_biguintn_gt(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnBiguintnGt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnBiguintnGt(params))) + return this + }, + /** + * Add a verify_biguintn_biguintn_gt(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnBiguintnGt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnBiguintnGt(params))) + return this + }, + /** + * Add a verify_uintn_uintn_ge(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnUintnGe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnUintnGe(params))) + return this + }, + /** + * Add a verify_biguintn_uintn_ge(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnUintnGe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnUintnGe(params))) + return this + }, + /** + * Add a verify_uintn_biguintn_ge(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnBiguintnGe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnBiguintnGe(params))) + return this + }, + /** + * Add a verify_biguintn_biguintn_ge(byte[],byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnBiguintnGe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnBiguintnGe(params))) + return this + }, + /** + * Add a verify_uintn_init(byte[])uint32 method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnInit(params))) + return this + }, + /** + * Add a verify_biguintn_init(byte[])uint256 method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnInit(params))) + return this + }, + /** + * Add a verify_uintn_from_bytes(byte[])uint32 method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnFromBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnFromBytes(params))) + return this + }, + /** + * Add a verify_biguintn_from_bytes(byte[])uint256 method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnFromBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnFromBytes(params))) + return this + }, + /** + * Add a verify_uintn_from_log(byte[])uint32 method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintnFromLog(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintnFromLog(params))) + return this + }, + /** + * Add a verify_biguintn_from_log(byte[])uint256 method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnFromLog(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnFromLog(params))) + return this + }, + /** + * Add a verify_biguintn_as_uint64(byte[])uint64 method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnAsUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnAsUint64(params))) + return this + }, + /** + * Add a verify_biguintn_as_biguint(byte[])uint512 method call against the Arc4PrimitiveOpsContract contract + */ + verifyBiguintnAsBiguint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintnAsBiguint(params))) + return this + }, + /** + * Add a verify_uintn64_as_uint64(byte[])uint64 method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintn64AsUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintn64AsUint64(params))) + return this + }, + /** + * Add a verify_uintn64_as_biguint(byte[])uint512 method call against the Arc4PrimitiveOpsContract contract + */ + verifyUintn64AsBiguint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUintn64AsBiguint(params))) + return this + }, + /** + * Add a verify_ufixednxm_bytes(ufixed32x8)byte[] method call against the Arc4PrimitiveOpsContract contract + */ + verifyUfixednxmBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUfixednxmBytes(params))) + return this + }, + /** + * Add a verify_bigufixednxm_bytes(ufixed256x16)byte[] method call against the Arc4PrimitiveOpsContract contract + */ + verifyBigufixednxmBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBigufixednxmBytes(params))) + return this + }, + /** + * Add a verify_ufixednxm_from_bytes(byte[])ufixed32x8 method call against the Arc4PrimitiveOpsContract contract + */ + verifyUfixednxmFromBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUfixednxmFromBytes(params))) + return this + }, + /** + * Add a verify_bigufixednxm_from_bytes(byte[])ufixed256x16 method call against the Arc4PrimitiveOpsContract contract + */ + verifyBigufixednxmFromBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBigufixednxmFromBytes(params))) + return this + }, + /** + * Add a verify_ufixednxm_from_log(byte[])ufixed32x8 method call against the Arc4PrimitiveOpsContract contract + */ + verifyUfixednxmFromLog(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUfixednxmFromLog(params))) + return this + }, + /** + * Add a verify_bigufixednxm_from_log(byte[])ufixed256x16 method call against the Arc4PrimitiveOpsContract contract + */ + verifyBigufixednxmFromLog(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBigufixednxmFromLog(params))) + return this + }, + /** + * Add a verify_string_init(string)string method call against the Arc4PrimitiveOpsContract contract + */ + verifyStringInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringInit(params))) + return this + }, + /** + * Add a verify_string_add(string,string)string method call against the Arc4PrimitiveOpsContract contract + */ + verifyStringAdd(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringAdd(params))) + return this + }, + /** + * Add a verify_string_eq(string,string)bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyStringEq(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringEq(params))) + return this + }, + /** + * Add a verify_string_bytes(string)byte[] method call against the Arc4PrimitiveOpsContract contract + */ + verifyStringBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringBytes(params))) + return this + }, + /** + * Add a verify_string_from_bytes(byte[])string method call against the Arc4PrimitiveOpsContract contract + */ + verifyStringFromBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringFromBytes(params))) + return this + }, + /** + * Add a verify_string_from_log(byte[])string method call against the Arc4PrimitiveOpsContract contract + */ + verifyStringFromLog(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringFromLog(params))) + return this + }, + /** + * Add a verify_bool_bytes(bool)byte[] method call against the Arc4PrimitiveOpsContract contract + */ + verifyBoolBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBoolBytes(params))) + return this + }, + /** + * Add a verify_bool_from_bytes(byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBoolFromBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBoolFromBytes(params))) + return this + }, + /** + * Add a verify_bool_from_log(byte[])bool method call against the Arc4PrimitiveOpsContract contract + */ + verifyBoolFromLog(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBoolFromLog(params))) + return this + }, + /** + * Add a verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void method call against the Arc4PrimitiveOpsContract contract + */ + verifyEmit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEmit(params))) + return this + }, + /** + * Add a clear state call to the Arc4PrimitiveOpsContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as Arc4PrimitiveOpsContractComposer + } +} +export type Arc4PrimitiveOpsContractComposer = { + /** + * Calls the verify_uintn_uintn_eq(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnUintnEq(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_eq(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_uintn_eq(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnUintnEq(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_eq(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_biguintn_eq(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnBiguintnEq(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_eq(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_biguintn_eq(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnBiguintnEq(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_eq(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_uintn_ne(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnUintnNe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_ne(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_uintn_ne(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnUintnNe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_ne(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_biguintn_ne(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnBiguintnNe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_ne(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_biguintn_ne(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnBiguintnNe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_ne(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_uintn_lt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnUintnLt(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_lt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_uintn_lt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnUintnLt(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_lt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_biguintn_lt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnBiguintnLt(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_lt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_biguintn_lt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnBiguintnLt(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_lt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_uintn_le(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnUintnLe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_le(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_uintn_le(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnUintnLe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_le(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_biguintn_le(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnBiguintnLe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_le(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_biguintn_le(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnBiguintnLe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_le(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_uintn_gt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnUintnGt(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_gt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_uintn_gt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnUintnGt(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_gt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_biguintn_gt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnBiguintnGt(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_gt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_biguintn_gt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnBiguintnGt(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_gt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_uintn_ge(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnUintnGe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_uintn_ge(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_uintn_ge(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnUintnGe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_uintn_ge(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_biguintn_ge(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnBiguintnGe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_biguintn_ge(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguintn_biguintn_ge(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnBiguintnGe(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_biguintn_ge(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_uintn_init(byte[])uint32 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnInit(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_init(byte[])uint32'] | undefined]> + + /** + * Calls the verify_biguintn_init(byte[])uint256 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnInit(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_init(byte[])uint256'] | undefined]> + + /** + * Calls the verify_uintn_from_bytes(byte[])uint32 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnFromBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_from_bytes(byte[])uint32'] | undefined]> + + /** + * Calls the verify_biguintn_from_bytes(byte[])uint256 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnFromBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_from_bytes(byte[])uint256'] | undefined]> + + /** + * Calls the verify_uintn_from_log(byte[])uint32 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintnFromLog(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn_from_log(byte[])uint32'] | undefined]> + + /** + * Calls the verify_biguintn_from_log(byte[])uint256 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnFromLog(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_from_log(byte[])uint256'] | undefined]> + + /** + * Calls the verify_biguintn_as_uint64(byte[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnAsUint64(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_as_uint64(byte[])uint64'] | undefined]> + + /** + * Calls the verify_biguintn_as_biguint(byte[])uint512 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintnAsBiguint(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_biguintn_as_biguint(byte[])uint512'] | undefined]> + + /** + * Calls the verify_uintn64_as_uint64(byte[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintn64AsUint64(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn64_as_uint64(byte[])uint64'] | undefined]> + + /** + * Calls the verify_uintn64_as_biguint(byte[])uint512 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUintn64AsBiguint(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_uintn64_as_biguint(byte[])uint512'] | undefined]> + + /** + * Calls the verify_ufixednxm_bytes(ufixed32x8)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUfixednxmBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_ufixednxm_bytes(ufixed32x8)byte[]'] | undefined]> + + /** + * Calls the verify_bigufixednxm_bytes(ufixed256x16)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBigufixednxmBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_bytes(ufixed256x16)byte[]'] | undefined]> + + /** + * Calls the verify_ufixednxm_from_bytes(byte[])ufixed32x8 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUfixednxmFromBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_ufixednxm_from_bytes(byte[])ufixed32x8'] | undefined]> + + /** + * Calls the verify_bigufixednxm_from_bytes(byte[])ufixed256x16 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBigufixednxmFromBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_from_bytes(byte[])ufixed256x16'] | undefined]> + + /** + * Calls the verify_ufixednxm_from_log(byte[])ufixed32x8 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUfixednxmFromLog(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_ufixednxm_from_log(byte[])ufixed32x8'] | undefined]> + + /** + * Calls the verify_bigufixednxm_from_log(byte[])ufixed256x16 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBigufixednxmFromLog(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_bigufixednxm_from_log(byte[])ufixed256x16'] | undefined]> + + /** + * Calls the verify_string_init(string)string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringInit(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_string_init(string)string'] | undefined]> + + /** + * Calls the verify_string_add(string,string)string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringAdd(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_string_add(string,string)string'] | undefined]> + + /** + * Calls the verify_string_eq(string,string)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringEq(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_string_eq(string,string)bool'] | undefined]> + + /** + * Calls the verify_string_bytes(string)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_string_bytes(string)byte[]'] | undefined]> + + /** + * Calls the verify_string_from_bytes(byte[])string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringFromBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_string_from_bytes(byte[])string'] | undefined]> + + /** + * Calls the verify_string_from_log(byte[])string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringFromLog(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_string_from_log(byte[])string'] | undefined]> + + /** + * Calls the verify_bool_bytes(bool)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBoolBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_bool_bytes(bool)byte[]'] | undefined]> + + /** + * Calls the verify_bool_from_bytes(byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBoolFromBytes(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_bool_from_bytes(byte[])bool'] | undefined]> + + /** + * Calls the verify_bool_from_log(byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBoolFromLog(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_bool_from_log(byte[])bool'] | undefined]> + + /** + * Calls the verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEmit(params?: CallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, Arc4PrimitiveOpsContractReturns['verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the Arc4PrimitiveOpsContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): Arc4PrimitiveOpsContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): Arc4PrimitiveOpsContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type Arc4PrimitiveOpsContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/BoxContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/BoxContract.ts new file mode 100644 index 0000000..146a2d5 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/BoxContract.ts @@ -0,0 +1,2352 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"BoxContract","structs":{"InnerStruct":[{"name":"c","type":"uint64"},{"name":"arrArr","type":"uint64[][]"},{"name":"d","type":"uint64"}],"LargeStruct":[{"name":"a","type":"byte[1024]"},{"name":"b","type":"byte[1024]"},{"name":"c","type":"byte[1024]"},{"name":"d","type":"byte[1024]"},{"name":"e","type":"uint64"},{"name":"f","type":"byte[1024]"},{"name":"g","type":"byte[1024]"},{"name":"h","type":"uint64"}],"NestedStruct":[{"name":"a","type":"uint64"},{"name":"inner","type":"InnerStruct"},{"name":"woah","type":"(uint64,uint64[][],uint64)[]"},{"name":"b","type":"uint64"}]},"methods":[{"name":"store_enums","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"read_enums","args":[],"returns":{"type":"(uint64,uint64)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_boxes","args":[{"type":"uint64","name":"a"},{"type":"byte[]","name":"b"},{"type":"string","name":"c"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"boxes_exist","args":[],"returns":{"type":"(bool,bool,bool,bool)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"check_keys","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"read_boxes","args":[],"returns":{"type":"(uint64,byte[],string,uint64)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"indirect_extract_and_replace","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"delete_boxes","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"slice_box","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"arc4_box","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"create_many_ints","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_many_ints","args":[{"type":"uint64","name":"index"},{"type":"uint64","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"sum_many_ints","args":[],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_box_ref","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_nested_struct","args":[{"type":"(uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64)","struct":"NestedStruct","name":"struct"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"nested_write","args":[{"type":"uint64","name":"index"},{"type":"uint64","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"nested_read","args":[{"type":"uint64","name":"i1"},{"type":"uint64","name":"i2"},{"type":"uint64","name":"i3"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"create_bools","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_bool","args":[{"type":"uint64","name":"index"},{"type":"bool","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"sum_bools","args":[{"type":"uint64","name":"stop_at_total"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"box_map_test","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"box_map_set","args":[{"type":"uint64","name":"key"},{"type":"string","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"box_map_get","args":[{"type":"uint64","name":"key"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"box_map_del","args":[{"type":"uint64","name":"key"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"box_map_exists","args":[{"type":"uint64","name":"key"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{"oca":{"keyType":"AVMString","valueType":"uint64","key":"b2Nh"},"txn":{"keyType":"AVMString","valueType":"uint64","key":"dHhu"},"box_a":{"keyType":"AVMString","valueType":"uint64","key":"Ym94X2E="},"box_b":{"keyType":"AVMString","valueType":"byte[]","key":"Yg=="},"box_c":{"keyType":"AVMBytes","valueType":"string","key":"Qk9YX0M="},"box_d":{"keyType":"AVMString","valueType":"AVMBytes","key":"Ym94X2Q="},"many_ints":{"keyType":"AVMString","valueType":"uint64[513]","key":"bWFueV9pbnRz"},"box_ref":{"keyType":"AVMString","valueType":"AVMBytes","key":"Ym94X3JlZg=="},"box_large":{"keyType":"AVMString","valueType":"LargeStruct","key":"Ym94X2xhcmdl"},"too_many_bools":{"keyType":"AVMString","valueType":"bool[33000]","key":"dG9vX21hbnlfYm9vbHM="}}},"maps":{"global":{},"local":{},"box":{"box_map":{"keyType":"uint64","valueType":"AVMString","prefix":""}}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[842],"errorMessage":"check Box exists"},{"pc":[486],"errorMessage":"check self.box_a exists"},{"pc":[851],"errorMessage":"check self.box_b exists"},{"pc":[514,857],"errorMessage":"check self.box_c exists"},{"pc":[1932],"errorMessage":"check self.box_map entry exists"},{"pc":[1178],"errorMessage":"check self.many_ints exists"},{"pc":[378],"errorMessage":"check self.oca exists"},{"pc":[1795],"errorMessage":"check self.too_many_bools exists"},{"pc":[390],"errorMessage":"check self.txn exists"},{"pc":[1773],"errorMessage":"index access is out of bounds"},{"pc":[1398,1425,1492,1517,1539,1587,1614,1660,1685,1710],"errorMessage":"index out of bounds"},{"pc":[1228],"errorMessage":"no data"},{"pc":[1329],"errorMessage":"struct.a is truthy"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 2 0 8 4096 4098 4138
    bytecblock "box" 0x424f585f43 "blob" "box_large" 0x151f7c75 "box_a" "box_d" "b" "too_many_bools" "many_ints" "0" 0x00023432 0x68656c6c6f 0x6f6361 0x74786e 0x068101 "box_ref" "default"
    // tests/artifacts/BoxContract/contract.py:59
    // class BoxContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@34
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0xf26c6d42 0xef186cf7 0x7d37296e 0xf13dd937 0x33325d3d 0xa6174812 0xfabcb885 0xd566c632 0x04ef4971 0x23ecb32c 0x0199408d 0x772059ca 0x01263df6 0xeef75816 0x996497ae 0x6cec72ff 0x6f9d1075 0x59ef3760 0xaa666b96 0xdfbdd636 0xb532913a 0xc29f1669 0x9c888c09 0xe6f68506 0x8ee2c364 // method "store_enums()void", method "read_enums()(uint64,uint64)", method "set_boxes(uint64,byte[],string)void", method "boxes_exist()(bool,bool,bool,bool)", method "check_keys()void", method "read_boxes()(uint64,byte[],string,uint64)", method "indirect_extract_and_replace()void", method "delete_boxes()void", method "slice_box()void", method "arc4_box()void", method "create_many_ints()void", method "set_many_ints(uint64,uint64)void", method "sum_many_ints()uint64", method "test_box_ref()void", method "set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void", method "nested_write(uint64,uint64)void", method "nested_read(uint64,uint64,uint64)uint64", method "create_bools()void", method "set_bool(uint64,bool)void", method "sum_bools(uint64)uint64", method "box_map_test()void", method "box_map_set(uint64,string)void", method "box_map_get(uint64)string", method "box_map_del(uint64)void", method "box_map_exists(uint64)bool"
    txna ApplicationArgs 0
    match store_enums read_enums set_boxes boxes_exist main_check_keys_route@10 read_boxes indirect_extract_and_replace delete_boxes slice_box main_arc4_box_route@15 main_create_many_ints_route@16 set_many_ints sum_many_ints test_box_ref set_nested_struct nested_write nested_read main_create_bools_route@23 set_bool sum_bools box_map_test box_map_set box_map_get box_map_del box_map_exists
    err

main_create_bools_route@23:
    // tests/artifacts/BoxContract/contract.py:281
    // self.too_many_bools.create()
    bytec 8 // "too_many_bools"
    pushint 4125
    box_create
    pop
    // tests/artifacts/BoxContract/contract.py:279
    // @arc4.abimethod
    intc_0 // 1
    return

main_create_many_ints_route@16:
    // tests/artifacts/BoxContract/contract.py:181
    // self.many_ints.create()
    bytec 9 // "many_ints"
    pushint 4104
    box_create
    pop
    // tests/artifacts/BoxContract/contract.py:179
    // @arc4.abimethod()
    intc_0 // 1
    return

main_arc4_box_route@15:
    // tests/artifacts/BoxContract/contract.py:171-172
    // box_d = Box(StaticInts, key=Bytes(b"d"))
    // box_d.value = StaticInts(arc4.UInt8(0), arc4.UInt8(1), arc4.UInt8(2), arc4.UInt8(3))
    pushbytess 0x64 0x00010203
    // tests/artifacts/BoxContract/contract.py:172
    // box_d.value = StaticInts(arc4.UInt8(0), arc4.UInt8(1), arc4.UInt8(2), arc4.UInt8(3))
    box_put
    // tests/artifacts/BoxContract/contract.py:169
    // @arc4.abimethod
    intc_0 // 1
    return

main_check_keys_route@10:
    // tests/artifacts/BoxContract/contract.py:125
    // @arc4.abimethod
    intc_0 // 1
    return

main___algopy_default_create@34:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.BoxContract.contract.BoxContract.store_enums[routing]() -> void:
store_enums:
    // tests/artifacts/BoxContract/contract.py:75
    // self.oca.value = OnCompleteAction.OptIn
    intc_0 // OptIn
    itob
    bytec 13 // "oca"
    swap
    box_put
    // tests/artifacts/BoxContract/contract.py:76
    // self.txn.value = TransactionType.ApplicationCall
    pushint 6 // appl
    itob
    bytec 14 // "txn"
    swap
    box_put
    // tests/artifacts/BoxContract/contract.py:73
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.read_enums[routing]() -> void:
read_enums:
    // tests/artifacts/BoxContract/contract.py:80
    // assert op.Box.get(b"oca")[0] == op.itob(self.oca.value)
    bytec 13 // 0x6f6361
    box_get
    assert // check self.oca exists
    dup
    btoi
    itob
    swap
    dig 1
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:81
    // assert op.Box.get(b"txn")[0] == op.itob(self.txn.value)
    bytec 14 // 0x74786e
    box_get
    assert // check self.txn exists
    dup
    btoi
    itob
    swap
    dig 1
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:83
    // return arc4.Tuple((arc4.UInt64(self.oca.value), arc4.UInt64(self.txn.value)))
    concat
    // tests/artifacts/BoxContract/contract.py:78
    // @arc4.abimethod()
    bytec 4 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.set_boxes[routing]() -> void:
set_boxes:
    // tests/artifacts/BoxContract/contract.py:85
    // @arc4.abimethod
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    // tests/artifacts/BoxContract/contract.py:87
    // self.box_a.value = a
    uncover 2
    itob
    bytec 5 // "box_a"
    swap
    box_put
    // tests/artifacts/BoxContract/contract.py:88
    // self.box_b.value = b.copy()
    bytec 7 // "b"
    box_del
    pop
    bytec 7 // "b"
    dig 2
    box_put
    // tests/artifacts/BoxContract/contract.py:89
    // self.box_c.value = c
    bytec_1 // 0x424f585f43
    box_del
    pop
    bytec_1 // 0x424f585f43
    dig 1
    box_put
    // tests/artifacts/BoxContract/contract.py:90
    // self.box_d.value = b.native
    dig 1
    extract 2 0
    bytec 6 // "box_d"
    box_del
    pop
    bytec 6 // "box_d"
    dig 1
    box_put
    // tests/artifacts/BoxContract/contract.py:91
    // self.box_large.create()
    bytec_3 // "box_large"
    pushint 6160
    box_create
    pop
    // tests/artifacts/BoxContract/contract.py:92
    // self.box_large.value.e = UInt64(42)
    pushint 42
    itob
    bytec_3 // "box_large"
    intc 4 // 4096
    uncover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:93
    // self.box_large.replace(size_of(Bytes1024) * 4, arc4.UInt64(42).bytes)
    bytec_3 // "box_large"
    intc 4 // 4096
    pushbytes 0x000000000000002a
    box_replace
    // tests/artifacts/BoxContract/contract.py:98
    // self.box_a.value += 3
    bytec 5 // "box_a"
    box_get
    assert // check self.box_a exists
    btoi
    pushint 3
    +
    itob
    bytec 5 // "box_a"
    swap
    box_put
    // tests/artifacts/BoxContract/contract.py:100-101
    // # test .length
    // assert self.box_a.length == 8
    bytec 5 // "box_a"
    box_len
    pop
    intc_3 // 8
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:102
    // assert self.box_b.length == b.bytes.length
    bytec 7 // "b"
    box_len
    pop
    dig 3
    len
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:103
    // assert self.box_c.length == c.bytes.length
    bytec_1 // 0x424f585f43
    box_len
    assert // check self.box_c exists
    dig 2
    len
    dup2
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:104
    // assert self.box_d.length == b.native.length
    bytec 6 // "box_d"
    box_len
    pop
    dig 3
    len
    dup2
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:106-107
    // # test .value.bytes
    // assert self.box_c.value.bytes[0] == c.bytes[0]
    bytec_1 // 0x424f585f43
    intc_2 // 0
    intc_0 // 1
    box_extract
    dig 6
    extract 0 1
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:108
    // assert self.box_c.value.bytes[-1] == c.bytes[-1]
    dig 3
    intc_0 // 1
    -
    bytec_1 // 0x424f585f43
    swap
    intc_0 // 1
    box_extract
    dig 3
    intc_0 // 1
    -
    dig 7
    swap
    intc_0 // 1
    extract3
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:109
    // assert self.box_c.value.bytes[:-1] == c.bytes[:-1]
    intc_0 // 1
    dig 4
    <
    dig 4
    intc_0 // 1
    uncover 2
    select
    dig 4
    swap
    -
    bytec_1 // 0x424f585f43
    intc_2 // 0
    uncover 2
    box_extract
    intc_0 // 1
    dig 4
    >=
    intc_0 // 1
    dig 5
    uncover 2
    select
    dig 4
    swap
    -
    dig 7
    intc_2 // 0
    uncover 2
    substring3
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:110
    // assert self.box_c.value.bytes[:2] == c.bytes[:2]
    intc_1 // 2
    dig 4
    <
    uncover 4
    intc_1 // 2
    uncover 2
    select
    bytec_1 // 0x424f585f43
    intc_2 // 0
    uncover 2
    box_extract
    intc_1 // 2
    dig 4
    >=
    intc_1 // 2
    uncover 5
    uncover 2
    select
    uncover 5
    intc_2 // 0
    uncover 2
    substring3
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:112-113
    // # test .value with Bytes type
    // assert self.box_d.value[0] == b.native[0]
    bytec 6 // "box_d"
    intc_2 // 0
    intc_0 // 1
    box_extract
    uncover 4
    extract 2 1
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:114
    // assert self.box_d.value[-1] == b.native[-1]
    dig 1
    intc_0 // 1
    -
    bytec 6 // "box_d"
    swap
    intc_0 // 1
    box_extract
    dig 1
    intc_0 // 1
    -
    dig 4
    swap
    intc_0 // 1
    extract3
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:115
    // assert self.box_d.value[:-1] == b.native[:-1]
    intc_0 // 1
    dig 2
    <
    dig 2
    intc_0 // 1
    uncover 2
    select
    dig 2
    swap
    -
    bytec 6 // "box_d"
    intc_2 // 0
    uncover 2
    box_extract
    intc_0 // 1
    dig 2
    >=
    intc_0 // 1
    dig 3
    uncover 2
    select
    dig 2
    swap
    -
    dig 4
    intc_2 // 0
    uncover 2
    substring3
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:116
    // assert self.box_d.value[:5] == b.native[:5]
    pushint 5
    dig 2
    <
    dig 2
    pushint 5
    uncover 2
    select
    bytec 6 // "box_d"
    intc_2 // 0
    uncover 2
    box_extract
    pushint 5
    dig 2
    >=
    pushint 5
    dig 3
    uncover 2
    select
    dig 4
    intc_2 // 0
    uncover 2
    substring3
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:117
    // assert self.box_d.value[: UInt64(2)] == b.native[: UInt64(2)]
    intc_1 // 2
    dig 2
    <
    uncover 2
    intc_1 // 2
    uncover 2
    select
    bytec 6 // "box_d"
    intc_2 // 0
    uncover 2
    box_extract
    intc_1 // 2
    dig 2
    >=
    intc_1 // 2
    uncover 3
    uncover 2
    select
    uncover 2
    intc_2 // 0
    uncover 2
    substring3
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:119
    // assert self.box_large.length == size_of(LargeStruct)
    bytec_3 // "box_large"
    box_len
    pop
    pushint 6160
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:85
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.boxes_exist[routing]() -> void:
boxes_exist:
    // tests/artifacts/BoxContract/contract.py:123
    // return bool(self.box_a), bool(self.box_b), bool(self.box_c), bool(self.box_large)
    bytec 5 // "box_a"
    box_len
    bury 1
    bytec 7 // "b"
    box_len
    cover 2
    pop
    bytec_1 // 0x424f585f43
    box_len
    cover 3
    pop
    bytec_3 // "box_large"
    box_len
    cover 4
    pop
    // tests/artifacts/BoxContract/contract.py:121
    // @arc4.abimethod
    pushbytes 0x00
    intc_2 // 0
    uncover 2
    setbit
    intc_0 // 1
    uncover 2
    setbit
    intc_1 // 2
    uncover 2
    setbit
    pushint 3
    uncover 2
    setbit
    bytec 4 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.read_boxes[routing]() -> void:
read_boxes:
    // tests/artifacts/BoxContract/contract.py:135
    // get_box_value_plus_1(self.box_a) - 1,
    bytec 5 // "box_a"
    // tests/artifacts/BoxContract/contract.py:345
    // return box.value + 1
    box_get
    assert // check Box exists
    btoi
    intc_0 // 1
    +
    // tests/artifacts/BoxContract/contract.py:135
    // get_box_value_plus_1(self.box_a) - 1,
    intc_0 // 1
    -
    // tests/artifacts/BoxContract/contract.py:136
    // self.box_b.value.native,
    bytec 7 // "b"
    box_get
    assert // check self.box_b exists
    extract 2 0
    // tests/artifacts/BoxContract/contract.py:137
    // self.box_c.value,
    bytec_1 // 0x424f585f43
    box_get
    assert // check self.box_c exists
    // tests/artifacts/BoxContract/contract.py:138
    // self.box_large.value.e,
    bytec_3 // "box_large"
    intc 4 // 4096
    intc_3 // 8
    box_extract
    btoi
    // tests/artifacts/BoxContract/contract.py:132
    // @arc4.abimethod
    uncover 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    pushbytes 0x0014
    concat
    dig 1
    len
    pushint 20
    +
    itob
    extract 6 2
    concat
    uncover 2
    itob
    concat
    swap
    concat
    swap
    concat
    bytec 4 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.indirect_extract_and_replace[routing]() -> void:
indirect_extract_and_replace:
    // tests/artifacts/BoxContract/contract.py:143
    // large = self.box_large.value.copy()
    bytec_3 // "box_large"
    // tests/artifacts/BoxContract/contract.py:143-144
    // large = self.box_large.value.copy()
    // large.e += 1
    intc 4 // 4096
    intc_3 // 8
    box_extract
    // tests/artifacts/BoxContract/contract.py:144
    // large.e += 1
    btoi
    intc_0 // 1
    +
    itob
    // tests/artifacts/BoxContract/contract.py:145
    // self.box_large.value = large.copy()
    bytec_3 // "box_large"
    // tests/artifacts/BoxContract/contract.py:143-145
    // large = self.box_large.value.copy()
    // large.e += 1
    // self.box_large.value = large.copy()
    intc 4 // 4096
    uncover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:141
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.delete_boxes[routing]() -> void:
delete_boxes:
    // tests/artifacts/BoxContract/contract.py:149
    // del self.box_a.value
    bytec 5 // "box_a"
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:150
    // del self.box_b.value
    bytec 7 // "b"
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:151
    // del self.box_c.value
    bytec_1 // 0x424f585f43
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:152
    // assert self.box_a.get(default=UInt64(42)) == 42
    bytec 5 // "box_a"
    box_get
    swap
    btoi
    pushint 42
    dig 1
    dig 3
    select
    pushint 42
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:153
    // assert self.box_b.get(default=arc4.DynamicBytes(b"42")).native == b"42"
    bytec 7 // "b"
    box_get
    bytec 11 // 0x00023432
    cover 2
    select
    extract 2 0
    pushbytes 0x3432
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:154
    // assert self.box_c.get(default=arc4.String("42")) == "42"
    bytec_1 // 0x424f585f43
    box_get
    bytec 11 // 0x00023432
    cover 2
    select
    bytec 11 // 0x00023432
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:156
    // assert not a_exists
    swap
    !
    assert
    // tests/artifacts/BoxContract/contract.py:157
    // assert a == 0
    !
    assert
    // tests/artifacts/BoxContract/contract.py:158
    // del self.box_large.value
    bytec_3 // "box_large"
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:147
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.slice_box[routing]() -> void:
slice_box:
    // tests/artifacts/BoxContract/contract.py:162
    // box_0 = Box(Bytes, key=String("0"))
    bytec 10 // "0"
    // tests/artifacts/BoxContract/contract.py:163
    // box_0.value = Bytes(b"Testing testing 123")
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:162
    // box_0 = Box(Bytes, key=String("0"))
    bytec 10 // "0"
    // tests/artifacts/BoxContract/contract.py:163
    // box_0.value = Bytes(b"Testing testing 123")
    pushbytes 0x54657374696e672074657374696e6720313233
    box_put
    // tests/artifacts/BoxContract/contract.py:162
    // box_0 = Box(Bytes, key=String("0"))
    bytec 10 // "0"
    // tests/artifacts/BoxContract/contract.py:164
    // assert box_0.value[0:7] == b"Testing"
    box_len
    pop
    dup
    intc_2 // 0
    dig 2
    select
    pushint 7
    dig 2
    <
    uncover 2
    pushint 7
    uncover 2
    select
    dig 1
    -
    // tests/artifacts/BoxContract/contract.py:162
    // box_0 = Box(Bytes, key=String("0"))
    bytec 10 // "0"
    // tests/artifacts/BoxContract/contract.py:164
    // assert box_0.value[0:7] == b"Testing"
    cover 2
    box_extract
    pushbytes 0x54657374696e67
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:166
    // self.box_c.value = arc4.String("Hello")
    bytec_1 // 0x424f585f43
    box_del
    pop
    bytec_1 // 0x424f585f43
    pushbytes 0x000548656c6c6f
    box_put
    // tests/artifacts/BoxContract/contract.py:167
    // assert self.box_c.value.bytes[2:10] == b"Hello"
    bytec_1 // 0x424f585f43
    box_len
    pop
    intc_1 // 2
    dig 1
    <
    dig 1
    intc_1 // 2
    uncover 2
    select
    pushint 10
    dig 2
    <
    uncover 2
    pushint 10
    uncover 2
    select
    dig 1
    -
    bytec_1 // 0x424f585f43
    cover 2
    box_extract
    pushbytes 0x48656c6c6f
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:160
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.set_many_ints[routing]() -> void:
set_many_ints:
    // tests/artifacts/BoxContract/contract.py:183
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    // tests/artifacts/BoxContract/contract.py:185
    // self.many_ints.value[index] = value
    swap
    intc_3 // 8
    *
    bytec 9 // "many_ints"
    swap
    uncover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:183
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.sum_many_ints[routing]() -> void:
sum_many_ints:
    pushbytes ""
    dup

sum_many_ints_while_top@7:
    pushint 10510
    global OpcodeBudget
    >
    bz sum_many_ints_after_while@12
    itxn_begin
    pushint 6 // appl
    itxn_field TypeEnum
    pushint 5 // DeleteApplication
    itxn_field OnCompletion
    bytec 15 // 0x068101
    itxn_field ApprovalProgram
    bytec 15 // 0x068101
    itxn_field ClearStateProgram
    intc_2 // 0
    itxn_field Fee
    itxn_submit
    b sum_many_ints_while_top@7

sum_many_ints_after_while@12:
    // tests/artifacts/BoxContract/contract.py:190
    // total = UInt64(0)
    intc_2 // 0
    bury 1
    // tests/artifacts/BoxContract/contract.py:191
    // for val in self.many_ints.value:
    bytec 9 // "many_ints"
    box_len
    bury 1
    assert // check self.many_ints exists
    intc_2 // 0
    bury 2

sum_many_ints_for_header@2:
    // tests/artifacts/BoxContract/contract.py:191
    // for val in self.many_ints.value:
    dig 1
    pushint 513
    <
    bz sum_many_ints_after_for@5
    dig 1
    dup
    intc_3 // 8
    *
    bytec 9 // "many_ints"
    swap
    intc_3 // 8
    box_extract
    btoi
    // tests/artifacts/BoxContract/contract.py:192
    // total = total + val
    dig 2
    +
    bury 2
    intc_0 // 1
    +
    bury 2
    b sum_many_ints_for_header@2

sum_many_ints_after_for@5:
    // tests/artifacts/BoxContract/contract.py:187
    // @arc4.abimethod()
    dup
    itob
    bytec 4 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.test_box_ref[routing]() -> void:
test_box_ref:
    // tests/artifacts/BoxContract/contract.py:197-198
    // # init ref, with valid key types
    // box_ref = Box(Bytes, key="blob")
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:199
    // assert not box_ref, "no data"
    box_len
    bury 1
    !
    assert // no data
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:207-208
    // # create
    // assert box_ref.create(size=UInt64(32))
    pushint 32
    box_create
    assert
    // tests/artifacts/BoxContract/contract.py:211-212
    // # manipulate data
    // sender_bytes = Txn.sender.bytes
    txn Sender
    // tests/artifacts/BoxContract/contract.py:213
    // app_address = Global.current_application_address.bytes
    global CurrentApplicationAddress
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:215
    // box_ref.replace(0, sender_bytes)
    intc_2 // 0
    dig 3
    box_replace
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:216
    // box_ref.resize(8000)
    pushint 8000
    box_resize
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:217
    // box_ref.splice(0, 0, app_address)
    intc_2 // 0
    dup
    dig 3
    box_splice
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:218
    // box_ref.replace(64, value_3)
    pushint 64
    // tests/artifacts/BoxContract/contract.py:214
    // value_3 = Bytes(b"hello")
    bytec 12 // 0x68656c6c6f
    // tests/artifacts/BoxContract/contract.py:218
    // box_ref.replace(64, value_3)
    box_replace
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:219
    // prefix = box_ref.extract(0, 32 * 2 + value_3.length)
    intc_2 // 0
    pushint 69
    box_extract
    // tests/artifacts/BoxContract/contract.py:220
    // assert prefix == app_address + sender_bytes + value_3
    dig 1
    dig 3
    concat
    // tests/artifacts/BoxContract/contract.py:214
    // value_3 = Bytes(b"hello")
    bytec 12 // 0x68656c6c6f
    // tests/artifacts/BoxContract/contract.py:220
    // assert prefix == app_address + sender_bytes + value_3
    concat
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:222-223
    // # delete
    // del box_ref.value
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:226-227
    // # query
    // value, exists = box_ref.maybe()
    box_get
    // tests/artifacts/BoxContract/contract.py:228
    // assert not exists
    dup
    !
    assert
    // tests/artifacts/BoxContract/contract.py:229
    // assert value == b""
    dig 1
    pushbytes 0x
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:230
    // assert box_ref.get(default=sender_bytes) == sender_bytes
    dig 3
    cover 2
    select
    dig 2
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:232-233
    // # update
    // box_ref.value = sender_bytes + app_address
    concat
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:232-233
    // # update
    // box_ref.value = sender_bytes + app_address
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:232-233
    // # update
    // box_ref.value = sender_bytes + app_address
    swap
    box_put
    // tests/artifacts/BoxContract/contract.py:204
    // box_ref = Box(Bytes, key=String("blob"))
    bytec_2 // "blob"
    // tests/artifacts/BoxContract/contract.py:234
    // assert box_ref, "Blob exists"
    box_len
    pop
    // tests/artifacts/BoxContract/contract.py:235
    // assert box_ref.length == 64
    pushint 64
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:238-239
    // # instance box ref
    // self.box_ref.create(size=UInt64(32))
    bytec 16 // "box_ref"
    pushint 32
    box_create
    pop
    // tests/artifacts/BoxContract/contract.py:241
    // del self.box_ref.value
    bytec 16 // "box_ref"
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:195
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.set_nested_struct[routing]() -> void:
set_nested_struct:
    // tests/artifacts/BoxContract/contract.py:243
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/BoxContract/contract.py:246
    // assert struct.a, "struct.a is truthy"
    intc_2 // 0
    extract_uint64
    assert // struct.a is truthy
    // tests/artifacts/BoxContract/contract.py:247
    // struct_bytes = Txn.application_args(1)
    txna ApplicationArgs 1
    // tests/artifacts/BoxContract/contract.py:248
    // struct_size = struct_bytes.length
    dup
    len
    // tests/artifacts/BoxContract/contract.py:249
    // tail_offset = UInt64(4096 + 2)
    intc 5 // 4098
    // tests/artifacts/BoxContract/contract.py:250-251
    // # initialize box to zero
    // box.create(size=tail_offset + struct_size)
    +
    // tests/artifacts/BoxContract/contract.py:245
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:250-251
    // # initialize box to zero
    // box.create(size=tail_offset + struct_size)
    swap
    box_create
    pop
    // tests/artifacts/BoxContract/contract.py:245
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:252-253
    // # set correct offset for dynamic portion
    // box.replace(tail_offset - 2, arc4.UInt16(tail_offset).bytes)
    intc 4 // 4096
    pushbytes 0x1002
    box_replace
    // tests/artifacts/BoxContract/contract.py:245
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:249
    // tail_offset = UInt64(4096 + 2)
    intc 5 // 4098
    // tests/artifacts/BoxContract/contract.py:254-255
    // # set dynamic data
    // box.replace(tail_offset, struct_bytes)
    uncover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:243
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.nested_write[routing]() -> void:
nested_write:
    // tests/artifacts/BoxContract/contract.py:257
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    dup
    btoi
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:260
    // box.value.nested.a = value
    intc 5 // 4098
    uncover 3
    box_replace
    // tests/artifacts/BoxContract/contract.py:261
    // box.value.nested.b = value + 1
    dup
    intc_0 // 1
    +
    itob
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:261
    // box.value.nested.b = value + 1
    pushint 4110
    uncover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:262
    // box.value.nested.inner.arr_arr[index][index] = value + 2
    dup
    intc_1 // 2
    +
    itob
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:262
    // box.value.nested.inner.arr_arr[index][index] = value + 2
    pushint 4136
    intc_1 // 2
    box_extract
    btoi
    dig 3
    >
    assert // index out of bounds
    intc_1 // 2
    dig 3
    *
    intc 6 // 4138
    dig 1
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:262
    // box.value.nested.inner.arr_arr[index][index] = value + 2
    swap
    intc_1 // 2
    box_extract
    btoi
    intc 6 // 4138
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:262
    // box.value.nested.inner.arr_arr[index][index] = value + 2
    dig 1
    intc_1 // 2
    box_extract
    btoi
    dig 5
    >
    assert // index out of bounds
    intc_1 // 2
    +
    dig 4
    intc_3 // 8
    *
    swap
    dig 1
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:262
    // box.value.nested.inner.arr_arr[index][index] = value + 2
    swap
    uncover 4
    box_replace
    // tests/artifacts/BoxContract/contract.py:263
    // box.value.nested.inner.c = value + 3
    dig 2
    pushint 3
    +
    itob
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:263
    // box.value.nested.inner.c = value + 3
    pushint 4118
    uncover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:264
    // box.value.nested.inner.d = value + 4
    dig 2
    pushint 4
    +
    itob
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:264
    // box.value.nested.inner.d = value + 4
    pushint 4128
    uncover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:265
    // box.value.nested.woah[index].arr_arr[index][index] = value + 5
    uncover 2
    pushint 5
    +
    itob
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:265
    // box.value.nested.woah[index].arr_arr[index][index] = value + 5
    pushint 4108
    intc_1 // 2
    box_extract
    btoi
    intc 5 // 4098
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:265
    // box.value.nested.woah[index].arr_arr[index][index] = value + 5
    dig 1
    intc_1 // 2
    box_extract
    btoi
    dig 5
    >
    assert // index out of bounds
    intc_1 // 2
    +
    dup
    dig 4
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:265
    // box.value.nested.woah[index].arr_arr[index][index] = value + 5
    swap
    intc_1 // 2
    box_extract
    btoi
    +
    pushint 18
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:265
    // box.value.nested.woah[index].arr_arr[index][index] = value + 5
    dig 1
    intc_1 // 2
    box_extract
    btoi
    dig 5
    >
    assert // index out of bounds
    intc_1 // 2
    +
    dup
    uncover 4
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:265
    // box.value.nested.woah[index].arr_arr[index][index] = value + 5
    swap
    intc_1 // 2
    box_extract
    btoi
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:265
    // box.value.nested.woah[index].arr_arr[index][index] = value + 5
    dig 1
    intc_1 // 2
    box_extract
    btoi
    uncover 4
    >
    assert // index out of bounds
    intc_1 // 2
    +
    uncover 2
    +
    // tests/artifacts/BoxContract/contract.py:259
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:265
    // box.value.nested.woah[index].arr_arr[index][index] = value + 5
    swap
    uncover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:257
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.nested_read[routing]() -> void:
nested_read:
    // tests/artifacts/BoxContract/contract.py:267
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:270
    // a = box.value.nested.a
    intc 5 // 4098
    intc_3 // 8
    box_extract
    btoi
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:271
    // b = box.value.nested.b
    pushint 4110
    intc_3 // 8
    box_extract
    btoi
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:272
    // arr_arr = box.value.nested.inner.arr_arr[i1][i2]
    pushint 4136
    intc_1 // 2
    box_extract
    btoi
    dig 5
    >
    assert // index out of bounds
    intc_1 // 2
    dig 5
    *
    intc 6 // 4138
    dig 1
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:272
    // arr_arr = box.value.nested.inner.arr_arr[i1][i2]
    swap
    intc_1 // 2
    box_extract
    btoi
    intc 6 // 4138
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:272
    // arr_arr = box.value.nested.inner.arr_arr[i1][i2]
    dig 1
    intc_1 // 2
    box_extract
    btoi
    dig 6
    >
    assert // index out of bounds
    intc_1 // 2
    +
    dig 5
    intc_3 // 8
    *
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:272
    // arr_arr = box.value.nested.inner.arr_arr[i1][i2]
    swap
    intc_3 // 8
    box_extract
    btoi
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:273
    // c = box.value.nested.inner.c
    pushint 4118
    intc_3 // 8
    box_extract
    btoi
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:274
    // d = box.value.nested.inner.d
    pushint 4128
    intc_3 // 8
    box_extract
    btoi
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:275
    // woah_arr_arr = box.value.nested.woah[i1].arr_arr[i2][i3]
    pushint 4108
    intc_1 // 2
    box_extract
    btoi
    intc 5 // 4098
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:275
    // woah_arr_arr = box.value.nested.woah[i1].arr_arr[i2][i3]
    dig 1
    intc_1 // 2
    box_extract
    btoi
    uncover 10
    >
    assert // index out of bounds
    intc_1 // 2
    +
    dup
    uncover 5
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:275
    // woah_arr_arr = box.value.nested.woah[i1].arr_arr[i2][i3]
    swap
    intc_1 // 2
    box_extract
    btoi
    +
    pushint 18
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:275
    // woah_arr_arr = box.value.nested.woah[i1].arr_arr[i2][i3]
    dig 1
    intc_1 // 2
    box_extract
    btoi
    dig 8
    >
    assert // index out of bounds
    intc_1 // 2
    +
    intc_1 // 2
    uncover 8
    *
    dig 1
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:275
    // woah_arr_arr = box.value.nested.woah[i1].arr_arr[i2][i3]
    swap
    intc_1 // 2
    box_extract
    btoi
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:275
    // woah_arr_arr = box.value.nested.woah[i1].arr_arr[i2][i3]
    dig 1
    intc_1 // 2
    box_extract
    btoi
    dig 7
    >
    assert // index out of bounds
    intc_1 // 2
    +
    uncover 6
    intc_3 // 8
    *
    +
    // tests/artifacts/BoxContract/contract.py:269
    // box = Box(LargeNestedStruct, key="box")
    bytec_0 // "box"
    // tests/artifacts/BoxContract/contract.py:275
    // woah_arr_arr = box.value.nested.woah[i1].arr_arr[i2][i3]
    swap
    intc_3 // 8
    box_extract
    btoi
    // tests/artifacts/BoxContract/contract.py:277
    // return a + b + arr_arr + c + d + woah_arr_arr
    uncover 5
    uncover 5
    +
    uncover 4
    +
    uncover 3
    +
    uncover 2
    +
    +
    // tests/artifacts/BoxContract/contract.py:267
    // @arc4.abimethod()
    itob
    bytec 4 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.set_bool[routing]() -> void:
set_bool:
    // tests/artifacts/BoxContract/contract.py:283
    // @arc4.abimethod
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    intc_2 // 0
    getbit
    // tests/artifacts/BoxContract/contract.py:285
    // self.too_many_bools.value[index] = value
    dig 1
    intc_3 // 8
    /
    uncover 2
    intc_3 // 8
    %
    bytec 8 // "too_many_bools"
    dig 2
    intc_0 // 1
    box_extract
    dig 1
    intc_3 // 8
    <
    assert // index access is out of bounds
    swap
    uncover 3
    setbit
    bytec 8 // "too_many_bools"
    cover 2
    box_replace
    // tests/artifacts/BoxContract/contract.py:283
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.sum_bools[routing]() -> void:
sum_bools:
    // tests/artifacts/BoxContract/contract.py:287
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/BoxContract/contract.py:289
    // total = UInt64()
    intc_2 // 0
    // tests/artifacts/BoxContract/contract.py:290
    // for value in self.too_many_bools.value:
    bytec 8 // "too_many_bools"
    box_len
    bury 1
    assert // check self.too_many_bools exists
    intc_2 // 0

sum_bools_for_header@2:
    // tests/artifacts/BoxContract/contract.py:290
    // for value in self.too_many_bools.value:
    dup
    pushint 33000
    <
    bz sum_bools_after_for@9
    dupn 2
    intc_3 // 8
    /
    swap
    intc_3 // 8
    %
    bytec 8 // "too_many_bools"
    uncover 2
    intc_0 // 1
    box_extract
    swap
    getbit
    // tests/artifacts/BoxContract/contract.py:291
    // if value:
    bz sum_bools_after_if_else@5
    // tests/artifacts/BoxContract/contract.py:292
    // total += 1
    dig 1
    intc_0 // 1
    +
    bury 2

sum_bools_after_if_else@5:
    // tests/artifacts/BoxContract/contract.py:293
    // if total == stop_at_total:
    dig 1
    dig 3
    ==
    bnz sum_bools_after_for@9
    dup
    intc_0 // 1
    +
    bury 1
    b sum_bools_for_header@2

sum_bools_after_for@9:
    // tests/artifacts/BoxContract/contract.py:287
    // @arc4.abimethod()
    dig 1
    itob
    bytec 4 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.box_map_test[routing]() -> void:
box_map_test:
    // tests/artifacts/BoxContract/contract.py:299
    // key_0 = UInt64(0)
    intc_2 // 0
    // tests/artifacts/BoxContract/contract.py:302
    // self.box_map[key_0] = value
    itob
    dup
    box_del
    pop
    dup
    // tests/artifacts/BoxContract/contract.py:301
    // value = String("Hmmmmm")
    pushbytes "Hmmmmm"
    // tests/artifacts/BoxContract/contract.py:302
    // self.box_map[key_0] = value
    box_put
    // tests/artifacts/BoxContract/contract.py:305
    // assert self.box_map[key_0].bytes.length == value.bytes.length
    box_len
    pop
    pushint 6
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:300
    // key_1 = UInt64(1)
    intc_0 // 1
    // tests/artifacts/BoxContract/contract.py:309
    // assert self.box_map.get(key_1, default=String("default")) == String("default")
    itob
    dup
    box_get
    bytec 17 // "default"
    cover 2
    select
    bytec 17 // "default"
    ==
    assert
    // tests/artifacts/BoxContract/contract.py:310
    // value, exists = self.box_map.maybe(key_1)
    dup
    box_len
    bury 1
    // tests/artifacts/BoxContract/contract.py:311
    // assert not exists
    !
    assert
    // tests/artifacts/BoxContract/contract.py:317
    // tmp_box_map[key_1] = String("hello")
    dup
    box_del
    pop
    dup
    bytec 12 // "hello"
    box_put
    // tests/artifacts/BoxContract/contract.py:319
    // del tmp_box_map[key_1]
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:297
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.box_map_set[routing]() -> void:
box_map_set:
    // tests/artifacts/BoxContract/contract.py:321
    // @arc4.abimethod
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/BoxContract/contract.py:323
    // self.box_map[key] = value
    swap
    itob
    dup
    box_del
    pop
    swap
    box_put
    // tests/artifacts/BoxContract/contract.py:321
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.box_map_get[routing]() -> void:
box_map_get:
    // tests/artifacts/BoxContract/contract.py:325
    // @arc4.abimethod
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/BoxContract/contract.py:327
    // return self.box_map[key]
    itob
    box_get
    assert // check self.box_map entry exists
    // tests/artifacts/BoxContract/contract.py:325
    // @arc4.abimethod
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec 4 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.box_map_del[routing]() -> void:
box_map_del:
    // tests/artifacts/BoxContract/contract.py:329
    // @arc4.abimethod
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/BoxContract/contract.py:331
    // del self.box_map[key]
    itob
    box_del
    pop
    // tests/artifacts/BoxContract/contract.py:329
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.BoxContract.contract.BoxContract.box_map_exists[routing]() -> void:
box_map_exists:
    // tests/artifacts/BoxContract/contract.py:333
    // @arc4.abimethod
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/BoxContract/contract.py:335
    // return key in self.box_map
    itob
    box_len
    bury 1
    // tests/artifacts/BoxContract/contract.py:333
    // @arc4.abimethod
    pushbytes 0x00
    intc_2 // 0
    uncover 2
    setbit
    bytec 4 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"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","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +// Type definitions for ARC-56 structs + +export type InnerStruct = { + c: bigint, + arrArr: bigint[][], + d: bigint +} + + +/** + * Converts the ABI tuple representation of a InnerStruct to the struct representation + */ +export function InnerStructFromTuple(abiTuple: [bigint, bigint[][], bigint]) { + const abiStructType = ABIStructType.fromStruct('InnerStruct', APP_SPEC.structs) + return getStructValueFromTupleValue(abiStructType, abiTuple) as InnerStruct +} + +export type LargeStruct = { + a: Uint8Array, + b: Uint8Array, + c: Uint8Array, + d: Uint8Array, + e: bigint, + f: Uint8Array, + g: Uint8Array, + h: bigint +} + + +/** + * Converts the ABI tuple representation of a LargeStruct to the struct representation + */ +export function LargeStructFromTuple(abiTuple: [Uint8Array, Uint8Array, Uint8Array, Uint8Array, bigint, Uint8Array, Uint8Array, bigint]) { + const abiStructType = ABIStructType.fromStruct('LargeStruct', APP_SPEC.structs) + return getStructValueFromTupleValue(abiStructType, abiTuple) as LargeStruct +} + +export type NestedStruct = { + a: bigint, + inner: InnerStruct, + woah: [bigint, bigint[][], bigint][], + b: bigint +} + + +/** + * Converts the ABI tuple representation of a NestedStruct to the struct representation + */ +export function NestedStructFromTuple(abiTuple: [bigint, InnerStruct, [bigint, bigint[][], bigint][], bigint]) { + const abiStructType = ABIStructType.fromStruct('NestedStruct', APP_SPEC.structs) + return getStructValueFromTupleValue(abiStructType, abiTuple) as NestedStruct +} + +/** + * The argument types for the BoxContract contract + */ +export type BoxContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'store_enums()void': Record + 'read_enums()(uint64,uint64)': Record + 'set_boxes(uint64,byte[],string)void': { + a: bigint | number + b: Uint8Array + c: string + } + 'boxes_exist()(bool,bool,bool,bool)': Record + 'check_keys()void': Record + 'read_boxes()(uint64,byte[],string,uint64)': Record + 'indirect_extract_and_replace()void': Record + 'delete_boxes()void': Record + 'slice_box()void': Record + 'arc4_box()void': Record + 'create_many_ints()void': Record + 'set_many_ints(uint64,uint64)void': { + index: bigint | number + value: bigint | number + } + 'sum_many_ints()uint64': Record + 'test_box_ref()void': Record + 'set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void': { + struct: NestedStruct + } + 'nested_write(uint64,uint64)void': { + index: bigint | number + value: bigint | number + } + 'nested_read(uint64,uint64,uint64)uint64': { + i1: bigint | number + i2: bigint | number + i3: bigint | number + } + 'create_bools()void': Record + 'set_bool(uint64,bool)void': { + index: bigint | number + value: boolean + } + 'sum_bools(uint64)uint64': { + stopAtTotal: bigint | number + } + 'box_map_test()void': Record + 'box_map_set(uint64,string)void': { + key: bigint | number + value: string + } + 'box_map_get(uint64)string': { + key: bigint | number + } + 'box_map_del(uint64)void': { + key: bigint | number + } + 'box_map_exists(uint64)bool': { + key: bigint | number + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'store_enums()void': [] + 'read_enums()(uint64,uint64)': [] + 'set_boxes(uint64,byte[],string)void': [a: bigint | number, b: Uint8Array, c: string] + 'boxes_exist()(bool,bool,bool,bool)': [] + 'check_keys()void': [] + 'read_boxes()(uint64,byte[],string,uint64)': [] + 'indirect_extract_and_replace()void': [] + 'delete_boxes()void': [] + 'slice_box()void': [] + 'arc4_box()void': [] + 'create_many_ints()void': [] + 'set_many_ints(uint64,uint64)void': [index: bigint | number, value: bigint | number] + 'sum_many_ints()uint64': [] + 'test_box_ref()void': [] + 'set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void': [struct: NestedStruct] + 'nested_write(uint64,uint64)void': [index: bigint | number, value: bigint | number] + 'nested_read(uint64,uint64,uint64)uint64': [i1: bigint | number, i2: bigint | number, i3: bigint | number] + 'create_bools()void': [] + 'set_bool(uint64,bool)void': [index: bigint | number, value: boolean] + 'sum_bools(uint64)uint64': [stopAtTotal: bigint | number] + 'box_map_test()void': [] + 'box_map_set(uint64,string)void': [key: bigint | number, value: string] + 'box_map_get(uint64)string': [key: bigint | number] + 'box_map_del(uint64)void': [key: bigint | number] + 'box_map_exists(uint64)bool': [key: bigint | number] + } +} + +/** + * The return type for each method + */ +export type BoxContractReturns = { + 'store_enums()void': void + 'read_enums()(uint64,uint64)': [bigint, bigint] + 'set_boxes(uint64,byte[],string)void': void + 'boxes_exist()(bool,bool,bool,bool)': [boolean, boolean, boolean, boolean] + 'check_keys()void': void + 'read_boxes()(uint64,byte[],string,uint64)': [bigint, Uint8Array, string, bigint] + 'indirect_extract_and_replace()void': void + 'delete_boxes()void': void + 'slice_box()void': void + 'arc4_box()void': void + 'create_many_ints()void': void + 'set_many_ints(uint64,uint64)void': void + 'sum_many_ints()uint64': bigint + 'test_box_ref()void': void + 'set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void': void + 'nested_write(uint64,uint64)void': void + 'nested_read(uint64,uint64,uint64)uint64': bigint + 'create_bools()void': void + 'set_bool(uint64,bool)void': void + 'sum_bools(uint64)uint64': bigint + 'box_map_test()void': void + 'box_map_set(uint64,string)void': void + 'box_map_get(uint64)string': string + 'box_map_del(uint64)void': void + 'box_map_exists(uint64)bool': boolean +} + +/** + * Defines the types of available calls and state of the BoxContract smart contract. + */ +export type BoxContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'store_enums()void' | 'store_enums', { + argsObj: BoxContractArgs['obj']['store_enums()void'] + argsTuple: BoxContractArgs['tuple']['store_enums()void'] + returns: BoxContractReturns['store_enums()void'] + }> + & Record<'read_enums()(uint64,uint64)' | 'read_enums', { + argsObj: BoxContractArgs['obj']['read_enums()(uint64,uint64)'] + argsTuple: BoxContractArgs['tuple']['read_enums()(uint64,uint64)'] + returns: BoxContractReturns['read_enums()(uint64,uint64)'] + }> + & Record<'set_boxes(uint64,byte[],string)void' | 'set_boxes', { + argsObj: BoxContractArgs['obj']['set_boxes(uint64,byte[],string)void'] + argsTuple: BoxContractArgs['tuple']['set_boxes(uint64,byte[],string)void'] + returns: BoxContractReturns['set_boxes(uint64,byte[],string)void'] + }> + & Record<'boxes_exist()(bool,bool,bool,bool)' | 'boxes_exist', { + argsObj: BoxContractArgs['obj']['boxes_exist()(bool,bool,bool,bool)'] + argsTuple: BoxContractArgs['tuple']['boxes_exist()(bool,bool,bool,bool)'] + returns: BoxContractReturns['boxes_exist()(bool,bool,bool,bool)'] + }> + & Record<'check_keys()void' | 'check_keys', { + argsObj: BoxContractArgs['obj']['check_keys()void'] + argsTuple: BoxContractArgs['tuple']['check_keys()void'] + returns: BoxContractReturns['check_keys()void'] + }> + & Record<'read_boxes()(uint64,byte[],string,uint64)' | 'read_boxes', { + argsObj: BoxContractArgs['obj']['read_boxes()(uint64,byte[],string,uint64)'] + argsTuple: BoxContractArgs['tuple']['read_boxes()(uint64,byte[],string,uint64)'] + returns: BoxContractReturns['read_boxes()(uint64,byte[],string,uint64)'] + }> + & Record<'indirect_extract_and_replace()void' | 'indirect_extract_and_replace', { + argsObj: BoxContractArgs['obj']['indirect_extract_and_replace()void'] + argsTuple: BoxContractArgs['tuple']['indirect_extract_and_replace()void'] + returns: BoxContractReturns['indirect_extract_and_replace()void'] + }> + & Record<'delete_boxes()void' | 'delete_boxes', { + argsObj: BoxContractArgs['obj']['delete_boxes()void'] + argsTuple: BoxContractArgs['tuple']['delete_boxes()void'] + returns: BoxContractReturns['delete_boxes()void'] + }> + & Record<'slice_box()void' | 'slice_box', { + argsObj: BoxContractArgs['obj']['slice_box()void'] + argsTuple: BoxContractArgs['tuple']['slice_box()void'] + returns: BoxContractReturns['slice_box()void'] + }> + & Record<'arc4_box()void' | 'arc4_box', { + argsObj: BoxContractArgs['obj']['arc4_box()void'] + argsTuple: BoxContractArgs['tuple']['arc4_box()void'] + returns: BoxContractReturns['arc4_box()void'] + }> + & Record<'create_many_ints()void' | 'create_many_ints', { + argsObj: BoxContractArgs['obj']['create_many_ints()void'] + argsTuple: BoxContractArgs['tuple']['create_many_ints()void'] + returns: BoxContractReturns['create_many_ints()void'] + }> + & Record<'set_many_ints(uint64,uint64)void' | 'set_many_ints', { + argsObj: BoxContractArgs['obj']['set_many_ints(uint64,uint64)void'] + argsTuple: BoxContractArgs['tuple']['set_many_ints(uint64,uint64)void'] + returns: BoxContractReturns['set_many_ints(uint64,uint64)void'] + }> + & Record<'sum_many_ints()uint64' | 'sum_many_ints', { + argsObj: BoxContractArgs['obj']['sum_many_ints()uint64'] + argsTuple: BoxContractArgs['tuple']['sum_many_ints()uint64'] + returns: BoxContractReturns['sum_many_ints()uint64'] + }> + & Record<'test_box_ref()void' | 'test_box_ref', { + argsObj: BoxContractArgs['obj']['test_box_ref()void'] + argsTuple: BoxContractArgs['tuple']['test_box_ref()void'] + returns: BoxContractReturns['test_box_ref()void'] + }> + & Record<'set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void' | 'set_nested_struct', { + argsObj: BoxContractArgs['obj']['set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void'] + argsTuple: BoxContractArgs['tuple']['set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void'] + returns: BoxContractReturns['set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void'] + }> + & Record<'nested_write(uint64,uint64)void' | 'nested_write', { + argsObj: BoxContractArgs['obj']['nested_write(uint64,uint64)void'] + argsTuple: BoxContractArgs['tuple']['nested_write(uint64,uint64)void'] + returns: BoxContractReturns['nested_write(uint64,uint64)void'] + }> + & Record<'nested_read(uint64,uint64,uint64)uint64' | 'nested_read', { + argsObj: BoxContractArgs['obj']['nested_read(uint64,uint64,uint64)uint64'] + argsTuple: BoxContractArgs['tuple']['nested_read(uint64,uint64,uint64)uint64'] + returns: BoxContractReturns['nested_read(uint64,uint64,uint64)uint64'] + }> + & Record<'create_bools()void' | 'create_bools', { + argsObj: BoxContractArgs['obj']['create_bools()void'] + argsTuple: BoxContractArgs['tuple']['create_bools()void'] + returns: BoxContractReturns['create_bools()void'] + }> + & Record<'set_bool(uint64,bool)void' | 'set_bool', { + argsObj: BoxContractArgs['obj']['set_bool(uint64,bool)void'] + argsTuple: BoxContractArgs['tuple']['set_bool(uint64,bool)void'] + returns: BoxContractReturns['set_bool(uint64,bool)void'] + }> + & Record<'sum_bools(uint64)uint64' | 'sum_bools', { + argsObj: BoxContractArgs['obj']['sum_bools(uint64)uint64'] + argsTuple: BoxContractArgs['tuple']['sum_bools(uint64)uint64'] + returns: BoxContractReturns['sum_bools(uint64)uint64'] + }> + & Record<'box_map_test()void' | 'box_map_test', { + argsObj: BoxContractArgs['obj']['box_map_test()void'] + argsTuple: BoxContractArgs['tuple']['box_map_test()void'] + returns: BoxContractReturns['box_map_test()void'] + }> + & Record<'box_map_set(uint64,string)void' | 'box_map_set', { + argsObj: BoxContractArgs['obj']['box_map_set(uint64,string)void'] + argsTuple: BoxContractArgs['tuple']['box_map_set(uint64,string)void'] + returns: BoxContractReturns['box_map_set(uint64,string)void'] + }> + & Record<'box_map_get(uint64)string' | 'box_map_get', { + argsObj: BoxContractArgs['obj']['box_map_get(uint64)string'] + argsTuple: BoxContractArgs['tuple']['box_map_get(uint64)string'] + returns: BoxContractReturns['box_map_get(uint64)string'] + }> + & Record<'box_map_del(uint64)void' | 'box_map_del', { + argsObj: BoxContractArgs['obj']['box_map_del(uint64)void'] + argsTuple: BoxContractArgs['tuple']['box_map_del(uint64)void'] + returns: BoxContractReturns['box_map_del(uint64)void'] + }> + & Record<'box_map_exists(uint64)bool' | 'box_map_exists', { + argsObj: BoxContractArgs['obj']['box_map_exists(uint64)bool'] + argsTuple: BoxContractArgs['tuple']['box_map_exists(uint64)bool'] + returns: BoxContractReturns['box_map_exists(uint64)bool'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + box: { + keys: { + oca: bigint + txn: bigint + boxA: bigint + boxB: Uint8Array + boxC: string + boxD: BinaryState + manyInts: [bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint] + boxRef: BinaryState + boxLarge: LargeStruct + tooManyBools: [boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean] + } + maps: { + boxMap: Map + } + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type BoxContractSignatures = keyof BoxContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type BoxContractNonVoidMethodSignatures = keyof BoxContractTypes['methods'] extends infer T ? T extends keyof BoxContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the BoxContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = BoxContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the BoxContract smart contract to the method's return type + */ +export type MethodReturn = BoxContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed box state of the application. + */ +export type BoxKeysState = BoxContractTypes['state']['box']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type BoxContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type BoxContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: BoxContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the BoxContract smart contract + */ +export abstract class BoxContractParamsFactory { + /** + * Constructs a no op call for the store_enums()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static storeEnums(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'store_enums()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the read_enums()(uint64,uint64) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static readEnums(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'read_enums()(uint64,uint64)' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the set_boxes(uint64,byte[],string)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setBoxes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_boxes(uint64,byte[],string)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the boxes_exist()(bool,bool,bool,bool) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static boxesExist(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'boxes_exist()(bool,bool,bool,bool)' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the check_keys()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static checkKeys(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'check_keys()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the read_boxes()(uint64,byte[],string,uint64) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static readBoxes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'read_boxes()(uint64,byte[],string,uint64)' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the indirect_extract_and_replace()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static indirectExtractAndReplace(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'indirect_extract_and_replace()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the delete_boxes()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static deleteBoxes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'delete_boxes()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the slice_box()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static sliceBox(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'slice_box()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the arc4_box()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static arc4Box(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'arc4_box()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the create_many_ints()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static createManyInts(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'create_many_ints()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the set_many_ints(uint64,uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setManyInts(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_many_ints(uint64,uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.index, params.args.value], + } + } + /** + * Constructs a no op call for the sum_many_ints()uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static sumManyInts(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'sum_many_ints()uint64' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_box_ref()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testBoxRef(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_box_ref()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setNestedStruct(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.struct], + } + } + /** + * Constructs a no op call for the nested_write(uint64,uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static nestedWrite(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'nested_write(uint64,uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.index, params.args.value], + } + } + /** + * Constructs a no op call for the nested_read(uint64,uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static nestedRead(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'nested_read(uint64,uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.i1, params.args.i2, params.args.i3], + } + } + /** + * Constructs a no op call for the create_bools()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static createBools(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'create_bools()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the set_bool(uint64,bool)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setBool(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_bool(uint64,bool)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.index, params.args.value], + } + } + /** + * Constructs a no op call for the sum_bools(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static sumBools(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'sum_bools(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.stopAtTotal], + } + } + /** + * Constructs a no op call for the box_map_test()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static boxMapTest(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'box_map_test()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the box_map_set(uint64,string)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static boxMapSet(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'box_map_set(uint64,string)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.key, params.args.value], + } + } + /** + * Constructs a no op call for the box_map_get(uint64)string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static boxMapGet(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'box_map_get(uint64)string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.key], + } + } + /** + * Constructs a no op call for the box_map_del(uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static boxMapDel(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'box_map_del(uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.key], + } + } + /** + * Constructs a no op call for the box_map_exists(uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static boxMapExists(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'box_map_exists(uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.key], + } + } +} + +/** + * A factory to create and deploy one or more instance of the BoxContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class BoxContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `BoxContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new BoxContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new BoxContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the BoxContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: BoxContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new BoxContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the BoxContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the BoxContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the BoxContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new BoxContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the BoxContract smart contract + */ +export class BoxContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `BoxContractClient` + * + * @param appClient An `AppClient` instance which has been created with the BoxContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `BoxContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `BoxContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new BoxContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `BoxContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new BoxContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the BoxContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the BoxContract smart contract using the `store_enums()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + storeEnums: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.storeEnums(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `read_enums()(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + readEnums: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.readEnums(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_boxes(uint64,byte[],string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.setBoxes(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `boxes_exist()(bool,bool,bool,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + boxesExist: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.boxesExist(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `check_keys()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + checkKeys: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.checkKeys(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `read_boxes()(uint64,byte[],string,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + readBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.readBoxes(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `indirect_extract_and_replace()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + indirectExtractAndReplace: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.indirectExtractAndReplace(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `delete_boxes()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + deleteBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.deleteBoxes(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `slice_box()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + sliceBox: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.sliceBox(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `arc4_box()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + arc4Box: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.arc4Box(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `create_many_ints()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + createManyInts: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.createManyInts(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_many_ints(uint64,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setManyInts: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.setManyInts(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `sum_many_ints()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + sumManyInts: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.sumManyInts(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `test_box_ref()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testBoxRef: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.testBoxRef(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setNestedStruct: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.setNestedStruct(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `nested_write(uint64,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + nestedWrite: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.nestedWrite(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `nested_read(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + nestedRead: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.nestedRead(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `create_bools()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + createBools: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.createBools(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_bool(uint64,bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setBool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.setBool(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `sum_bools(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + sumBools: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.sumBools(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_test()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + boxMapTest: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(BoxContractParamsFactory.boxMapTest(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_set(uint64,string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + boxMapSet: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.boxMapSet(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_get(uint64)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + boxMapGet: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.boxMapGet(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_del(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + boxMapDel: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.boxMapDel(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_exists(uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + boxMapExists: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(BoxContractParamsFactory.boxMapExists(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the BoxContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the BoxContract smart contract using the `store_enums()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + storeEnums: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.storeEnums(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `read_enums()(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + readEnums: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.readEnums(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_boxes(uint64,byte[],string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.setBoxes(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `boxes_exist()(bool,bool,bool,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + boxesExist: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.boxesExist(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `check_keys()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + checkKeys: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.checkKeys(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `read_boxes()(uint64,byte[],string,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + readBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.readBoxes(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `indirect_extract_and_replace()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + indirectExtractAndReplace: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.indirectExtractAndReplace(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `delete_boxes()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + deleteBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.deleteBoxes(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `slice_box()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + sliceBox: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.sliceBox(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `arc4_box()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + arc4Box: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.arc4Box(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `create_many_ints()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + createManyInts: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.createManyInts(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_many_ints(uint64,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setManyInts: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.setManyInts(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `sum_many_ints()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + sumManyInts: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.sumManyInts(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `test_box_ref()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testBoxRef: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.testBoxRef(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setNestedStruct: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.setNestedStruct(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `nested_write(uint64,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + nestedWrite: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.nestedWrite(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `nested_read(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + nestedRead: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.nestedRead(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `create_bools()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + createBools: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.createBools(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_bool(uint64,bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setBool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.setBool(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `sum_bools(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + sumBools: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.sumBools(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_test()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + boxMapTest: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.boxMapTest(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_set(uint64,string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + boxMapSet: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.boxMapSet(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_get(uint64)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + boxMapGet: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.boxMapGet(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_del(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + boxMapDel: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.boxMapDel(params)) + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_exists(uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + boxMapExists: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(BoxContractParamsFactory.boxMapExists(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the BoxContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the BoxContract smart contract using the `store_enums()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + storeEnums: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.storeEnums(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['store_enums()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `read_enums()(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + readEnums: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.readEnums(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['read_enums()(uint64,uint64)'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_boxes(uint64,byte[],string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setBoxes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.setBoxes(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['set_boxes(uint64,byte[],string)void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `boxes_exist()(bool,bool,bool,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + boxesExist: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.boxesExist(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['boxes_exist()(bool,bool,bool,bool)'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `check_keys()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + checkKeys: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.checkKeys(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['check_keys()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `read_boxes()(uint64,byte[],string,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + readBoxes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.readBoxes(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['read_boxes()(uint64,byte[],string,uint64)'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `indirect_extract_and_replace()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + indirectExtractAndReplace: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.indirectExtractAndReplace(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['indirect_extract_and_replace()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `delete_boxes()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + deleteBoxes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.deleteBoxes(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['delete_boxes()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `slice_box()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + sliceBox: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.sliceBox(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['slice_box()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `arc4_box()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + arc4Box: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.arc4Box(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['arc4_box()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `create_many_ints()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + createManyInts: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.createManyInts(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['create_many_ints()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_many_ints(uint64,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setManyInts: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.setManyInts(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['set_many_ints(uint64,uint64)void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `sum_many_ints()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + sumManyInts: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.sumManyInts(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['sum_many_ints()uint64'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `test_box_ref()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testBoxRef: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.testBoxRef(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['test_box_ref()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setNestedStruct: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.setNestedStruct(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `nested_write(uint64,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + nestedWrite: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.nestedWrite(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['nested_write(uint64,uint64)void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `nested_read(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + nestedRead: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.nestedRead(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['nested_read(uint64,uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `create_bools()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + createBools: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.createBools(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['create_bools()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `set_bool(uint64,bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setBool: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.setBool(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['set_bool(uint64,bool)void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `sum_bools(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + sumBools: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.sumBools(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['sum_bools(uint64)uint64'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_test()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + boxMapTest: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.boxMapTest(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['box_map_test()void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_set(uint64,string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + boxMapSet: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.boxMapSet(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['box_map_set(uint64,string)void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_get(uint64)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + boxMapGet: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.boxMapGet(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['box_map_get(uint64)string'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_del(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + boxMapDel: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.boxMapDel(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['box_map_del(uint64)void'])} + }, + + /** + * Makes a call to the BoxContract smart contract using the `box_map_exists(uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + boxMapExists: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(BoxContractParamsFactory.boxMapExists(params)) + return {...result, return: result.return as unknown as (undefined | BoxContractReturns['box_map_exists(uint64)bool'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new BoxContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current BoxContract app + */ + state = { + /** + * Methods to access box state for the current BoxContract app + */ + box: { + /** + * Get all current keyed values from box state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.box.getAll() + return { + oca: result.oca, + txn: result.txn, + boxA: result.box_a, + boxB: result.box_b, + boxC: result.box_c, + boxD: new BinaryStateValue(result.box_d), + manyInts: result.many_ints, + boxRef: new BinaryStateValue(result.box_ref), + boxLarge: result.box_large, + tooManyBools: result.too_many_bools, + } + }, + /** + * Get the current value of the oca key in box state + */ + oca: async (): Promise => { return (await this.appClient.state.box.getValue("oca")) as bigint | undefined }, + /** + * Get the current value of the txn key in box state + */ + txn: async (): Promise => { return (await this.appClient.state.box.getValue("txn")) as bigint | undefined }, + /** + * Get the current value of the box_a key in box state + */ + boxA: async (): Promise => { return (await this.appClient.state.box.getValue("box_a")) as bigint | undefined }, + /** + * Get the current value of the box_b key in box state + */ + boxB: async (): Promise => { return (await this.appClient.state.box.getValue("box_b")) as Uint8Array | undefined }, + /** + * Get the current value of the box_c key in box state + */ + boxC: async (): Promise => { return (await this.appClient.state.box.getValue("box_c")) as string | undefined }, + /** + * Get the current value of the box_d key in box state + */ + boxD: async (): Promise => { return new BinaryStateValue((await this.appClient.state.box.getValue("box_d")) as Uint8Array | undefined) }, + /** + * Get the current value of the many_ints key in box state + */ + manyInts: async (): Promise<[bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint] | undefined> => { return (await this.appClient.state.box.getValue("many_ints")) as [bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint] | undefined }, + /** + * Get the current value of the box_ref key in box state + */ + boxRef: async (): Promise => { return new BinaryStateValue((await this.appClient.state.box.getValue("box_ref")) as Uint8Array | undefined) }, + /** + * Get the current value of the box_large key in box state + */ + boxLarge: async (): Promise => { return (await this.appClient.state.box.getValue("box_large")) as LargeStruct | undefined }, + /** + * Get the current value of the too_many_bools key in box state + */ + tooManyBools: async (): Promise<[boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean] | undefined> => { return (await this.appClient.state.box.getValue("too_many_bools")) as [boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean] | undefined }, + /** + * Get values from the box_map map in box state + */ + boxMap: { + /** + * Get all current values of the box_map map in box state + */ + getMap: async (): Promise> => { return (await this.appClient.state.box.getMap("box_map")) as Map }, + /** + * Get a current value of the box_map map by key from box state + */ + value: async (key: bigint | number): Promise => { return await this.appClient.state.box.getMapValue("box_map", key) as string | undefined }, + }, + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): BoxContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a store_enums()void method call against the BoxContract contract + */ + storeEnums(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.storeEnums(params))) + return this + }, + /** + * Add a read_enums()(uint64,uint64) method call against the BoxContract contract + */ + readEnums(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.readEnums(params))) + return this + }, + /** + * Add a set_boxes(uint64,byte[],string)void method call against the BoxContract contract + */ + setBoxes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setBoxes(params))) + return this + }, + /** + * Add a boxes_exist()(bool,bool,bool,bool) method call against the BoxContract contract + */ + boxesExist(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.boxesExist(params))) + return this + }, + /** + * Add a check_keys()void method call against the BoxContract contract + */ + checkKeys(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.checkKeys(params))) + return this + }, + /** + * Add a read_boxes()(uint64,byte[],string,uint64) method call against the BoxContract contract + */ + readBoxes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.readBoxes(params))) + return this + }, + /** + * Add a indirect_extract_and_replace()void method call against the BoxContract contract + */ + indirectExtractAndReplace(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.indirectExtractAndReplace(params))) + return this + }, + /** + * Add a delete_boxes()void method call against the BoxContract contract + */ + deleteBoxes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.deleteBoxes(params))) + return this + }, + /** + * Add a slice_box()void method call against the BoxContract contract + */ + sliceBox(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.sliceBox(params))) + return this + }, + /** + * Add a arc4_box()void method call against the BoxContract contract + */ + arc4Box(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.arc4Box(params))) + return this + }, + /** + * Add a create_many_ints()void method call against the BoxContract contract + */ + createManyInts(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.createManyInts(params))) + return this + }, + /** + * Add a set_many_ints(uint64,uint64)void method call against the BoxContract contract + */ + setManyInts(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setManyInts(params))) + return this + }, + /** + * Add a sum_many_ints()uint64 method call against the BoxContract contract + */ + sumManyInts(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.sumManyInts(params))) + return this + }, + /** + * Add a test_box_ref()void method call against the BoxContract contract + */ + testBoxRef(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testBoxRef(params))) + return this + }, + /** + * Add a set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void method call against the BoxContract contract + */ + setNestedStruct(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setNestedStruct(params))) + return this + }, + /** + * Add a nested_write(uint64,uint64)void method call against the BoxContract contract + */ + nestedWrite(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.nestedWrite(params))) + return this + }, + /** + * Add a nested_read(uint64,uint64,uint64)uint64 method call against the BoxContract contract + */ + nestedRead(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.nestedRead(params))) + return this + }, + /** + * Add a create_bools()void method call against the BoxContract contract + */ + createBools(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.createBools(params))) + return this + }, + /** + * Add a set_bool(uint64,bool)void method call against the BoxContract contract + */ + setBool(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setBool(params))) + return this + }, + /** + * Add a sum_bools(uint64)uint64 method call against the BoxContract contract + */ + sumBools(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.sumBools(params))) + return this + }, + /** + * Add a box_map_test()void method call against the BoxContract contract + */ + boxMapTest(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.boxMapTest(params))) + return this + }, + /** + * Add a box_map_set(uint64,string)void method call against the BoxContract contract + */ + boxMapSet(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.boxMapSet(params))) + return this + }, + /** + * Add a box_map_get(uint64)string method call against the BoxContract contract + */ + boxMapGet(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.boxMapGet(params))) + return this + }, + /** + * Add a box_map_del(uint64)void method call against the BoxContract contract + */ + boxMapDel(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.boxMapDel(params))) + return this + }, + /** + * Add a box_map_exists(uint64)bool method call against the BoxContract contract + */ + boxMapExists(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.boxMapExists(params))) + return this + }, + /** + * Add a clear state call to the BoxContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as BoxContractComposer + } +} +export type BoxContractComposer = { + /** + * Calls the store_enums()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + storeEnums(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['store_enums()void'] | undefined]> + + /** + * Calls the read_enums()(uint64,uint64) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + readEnums(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['read_enums()(uint64,uint64)'] | undefined]> + + /** + * Calls the set_boxes(uint64,byte[],string)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setBoxes(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['set_boxes(uint64,byte[],string)void'] | undefined]> + + /** + * Calls the boxes_exist()(bool,bool,bool,bool) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + boxesExist(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['boxes_exist()(bool,bool,bool,bool)'] | undefined]> + + /** + * Calls the check_keys()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + checkKeys(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['check_keys()void'] | undefined]> + + /** + * Calls the read_boxes()(uint64,byte[],string,uint64) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + readBoxes(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['read_boxes()(uint64,byte[],string,uint64)'] | undefined]> + + /** + * Calls the indirect_extract_and_replace()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + indirectExtractAndReplace(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['indirect_extract_and_replace()void'] | undefined]> + + /** + * Calls the delete_boxes()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + deleteBoxes(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['delete_boxes()void'] | undefined]> + + /** + * Calls the slice_box()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + sliceBox(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['slice_box()void'] | undefined]> + + /** + * Calls the arc4_box()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + arc4Box(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['arc4_box()void'] | undefined]> + + /** + * Calls the create_many_ints()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + createManyInts(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['create_many_ints()void'] | undefined]> + + /** + * Calls the set_many_ints(uint64,uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setManyInts(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['set_many_ints(uint64,uint64)void'] | undefined]> + + /** + * Calls the sum_many_ints()uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + sumManyInts(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['sum_many_ints()uint64'] | undefined]> + + /** + * Calls the test_box_ref()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testBoxRef(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['test_box_ref()void'] | undefined]> + + /** + * Calls the set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setNestedStruct(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['set_nested_struct((uint64,(uint64,uint64[][],uint64),(uint64,uint64[][],uint64)[],uint64))void'] | undefined]> + + /** + * Calls the nested_write(uint64,uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + nestedWrite(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['nested_write(uint64,uint64)void'] | undefined]> + + /** + * Calls the nested_read(uint64,uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + nestedRead(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['nested_read(uint64,uint64,uint64)uint64'] | undefined]> + + /** + * Calls the create_bools()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + createBools(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['create_bools()void'] | undefined]> + + /** + * Calls the set_bool(uint64,bool)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setBool(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['set_bool(uint64,bool)void'] | undefined]> + + /** + * Calls the sum_bools(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + sumBools(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['sum_bools(uint64)uint64'] | undefined]> + + /** + * Calls the box_map_test()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + boxMapTest(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['box_map_test()void'] | undefined]> + + /** + * Calls the box_map_set(uint64,string)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + boxMapSet(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['box_map_set(uint64,string)void'] | undefined]> + + /** + * Calls the box_map_get(uint64)string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + boxMapGet(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['box_map_get(uint64)string'] | undefined]> + + /** + * Calls the box_map_del(uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + boxMapDel(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['box_map_del(uint64)void'] | undefined]> + + /** + * Calls the box_map_exists(uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + boxMapExists(params?: CallParams): BoxContractComposer<[...TReturns, BoxContractReturns['box_map_exists(uint64)bool'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the BoxContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): BoxContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): BoxContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type BoxContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/Contract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/Contract.ts new file mode 100644 index 0000000..aa62d61 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/Contract.ts @@ -0,0 +1,621 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"Contract","structs":{},"methods":[{"name":"test_falcon_verify","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_reject_version","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[138,226],"errorMessage":"application exists"},{"pc":[140],"errorMessage":"should be version 0"},{"pc":[229],"errorMessage":"should be version 1"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEyCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"DCADAQYAJgEEDIEBQzEbQQAdMRkURDEYRIICBL5WSZwErIqrQjYaAI4CAAkAFwAxGRQxGBQQQ4GBDq+AAElPAoUURCJDsSiyQoAxDDEbQQAagASg6BhyNhoAjgEAAQAxGYEEEjEYEERCAAgxGRQxGBQQQzFEgQESRIEBQ7JAI7IQJLIBs7Q9SXIJRBREsSiyQoAxDDEbQQAagAQkN408NhoAjgEAAQAxGYEFEjEYEERCAAgxGRQxGBQQQzFEgQISRIEBQ7JAgQSyGSKyREmyGIAEoOgYcrIaI7IQJLIBs0lyCUQiEkSxgQKyRLIYgQWyGYAEJDeNPLIaI7IQJLIBsyJD","clear":"DIEBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the Contract contract + */ +export type ContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'test_falcon_verify()void': Record + 'test_reject_version()void': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'test_falcon_verify()void': [] + 'test_reject_version()void': [] + } +} + +/** + * The return type for each method + */ +export type ContractReturns = { + 'test_falcon_verify()void': void + 'test_reject_version()void': void +} + +/** + * Defines the types of available calls and state of the Contract smart contract. + */ +export type ContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'test_falcon_verify()void' | 'test_falcon_verify', { + argsObj: ContractArgs['obj']['test_falcon_verify()void'] + argsTuple: ContractArgs['tuple']['test_falcon_verify()void'] + returns: ContractReturns['test_falcon_verify()void'] + }> + & Record<'test_reject_version()void' | 'test_reject_version', { + argsObj: ContractArgs['obj']['test_reject_version()void'] + argsTuple: ContractArgs['tuple']['test_reject_version()void'] + returns: ContractReturns['test_reject_version()void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type ContractSignatures = keyof ContractTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the Contract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = ContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the Contract smart contract to the method's return type + */ +export type MethodReturn = ContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type ContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type ContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: ContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the Contract smart contract + */ +export abstract class ContractParamsFactory { + /** + * Constructs a no op call for the test_falcon_verify()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testFalconVerify(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_falcon_verify()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_reject_version()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testRejectVersion(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_reject_version()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the Contract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class ContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `ContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new ContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new ContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the Contract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: ContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new ContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Contract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Contract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the Contract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new ContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the Contract smart contract + */ +export class ContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `ContractClient` + * + * @param appClient An `AppClient` instance which has been created with the Contract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `ContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `ContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new ContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `ContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new ContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the Contract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the Contract smart contract using the `test_falcon_verify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testFalconVerify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ContractParamsFactory.testFalconVerify(params)) + }, + + /** + * Makes a call to the Contract smart contract using the `test_reject_version()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testRejectVersion: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ContractParamsFactory.testRejectVersion(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the Contract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the Contract smart contract using the `test_falcon_verify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testFalconVerify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ContractParamsFactory.testFalconVerify(params)) + }, + + /** + * Makes a call to the Contract smart contract using the `test_reject_version()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testRejectVersion: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ContractParamsFactory.testRejectVersion(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the Contract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the Contract smart contract using the `test_falcon_verify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testFalconVerify: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ContractParamsFactory.testFalconVerify(params)) + return {...result, return: result.return as unknown as (undefined | ContractReturns['test_falcon_verify()void'])} + }, + + /** + * Makes a call to the Contract smart contract using the `test_reject_version()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testRejectVersion: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ContractParamsFactory.testRejectVersion(params)) + return {...result, return: result.return as unknown as (undefined | ContractReturns['test_reject_version()void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new ContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current Contract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): ContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a test_falcon_verify()void method call against the Contract contract + */ + testFalconVerify(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testFalconVerify(params))) + return this + }, + /** + * Add a test_reject_version()void method call against the Contract contract + */ + testRejectVersion(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testRejectVersion(params))) + return this + }, + /** + * Add a clear state call to the Contract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as ContractComposer + } +} +export type ContractComposer = { + /** + * Calls the test_falcon_verify()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testFalconVerify(params?: CallParams): ContractComposer<[...TReturns, ContractReturns['test_falcon_verify()void'] | undefined]> + + /** + * Calls the test_reject_version()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testRejectVersion(params?: CallParams): ContractComposer<[...TReturns, ContractReturns['test_reject_version()void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the Contract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): ContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): ContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type ContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/ContractV0.ts b/examples/p-py/projects/p-py-frontend/src/contracts/ContractV0.ts new file mode 100644 index 0000000..4c42a4d --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/ContractV0.ts @@ -0,0 +1,621 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"ContractV0","structs":{},"methods":[{"name":"update","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["UpdateApplication"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[45],"errorMessage":"can only update if caller expects this to be currently be v0"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDEyCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BVk0xMi9jb250cmFjdC5weTozMgogICAgLy8gY2xhc3MgQ29udHJhY3RWMChBUkM0Q29udHJhY3QsIGF2bV92ZXJzaW9uPTEyKToKICAgIHR4biBOdW1BcHBBcmdzCiAgICBieiBtYWluX19fYWxnb3B5X2RlZmF1bHRfY3JlYXRlQDUKICAgIHB1c2hieXRlcyAweGEwZTgxODcyIC8vIG1ldGhvZCAidXBkYXRlKCl2b2lkIgogICAgdHhuYSBBcHBsaWNhdGlvbkFyZ3MgMAogICAgbWF0Y2ggbWFpbl91cGRhdGVfcm91dGVAMwogICAgZXJyCgptYWluX3VwZGF0ZV9yb3V0ZUAzOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FWTTEyL2NvbnRyYWN0LnB5OjMzCiAgICAvLyBAYXJjNC5hYmltZXRob2QoYWxsb3dfYWN0aW9ucz0oIlVwZGF0ZUFwcGxpY2F0aW9uIiwpKQogICAgdHhuIE9uQ29tcGxldGlvbgogICAgcHVzaGludCA0IC8vIFVwZGF0ZUFwcGxpY2F0aW9uCiAgICA9PQogICAgdHhuIEFwcGxpY2F0aW9uSUQKICAgICYmCiAgICBhc3NlcnQKICAgIGIgdXBkYXRlCgptYWluX19fYWxnb3B5X2RlZmF1bHRfY3JlYXRlQDU6CiAgICB0eG4gT25Db21wbGV0aW9uCiAgICAhCiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgIQogICAgJiYKICAgIHJldHVybgoKCi8vIHRlc3RzLmFydGlmYWN0cy5BVk0xMi5jb250cmFjdC5Db250cmFjdFYwLnVwZGF0ZVtyb3V0aW5nXSgpIC0+IHZvaWQ6CnVwZGF0ZToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BVk0xMi9jb250cmFjdC5weTozNgogICAgLy8gVHhuLnJlamVjdF92ZXJzaW9uID09IDEKICAgIHR4biBSZWplY3RWZXJzaW9uCiAgICBwdXNoaW50IDEKICAgID09CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQVZNMTIvY29udHJhY3QucHk6MzUtMzcKICAgIC8vIGFzc2VydCAoCiAgICAvLyAgICAgVHhuLnJlamVjdF92ZXJzaW9uID09IDEKICAgIC8vICksICJjYW4gb25seSB1cGRhdGUgaWYgY2FsbGVyIGV4cGVjdHMgdGhpcyB0byBiZSBjdXJyZW50bHkgYmUgdjAiCiAgICBhc3NlcnQgLy8gY2FuIG9ubHkgdXBkYXRlIGlmIGNhbGxlciBleHBlY3RzIHRoaXMgdG8gYmUgY3VycmVudGx5IGJlIHYwCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQVZNMTIvY29udHJhY3QucHk6MzMKICAgIC8vIEBhcmM0LmFiaW1ldGhvZChhbGxvd19hY3Rpb25zPSgiVXBkYXRlQXBwbGljYXRpb24iLCkpCiAgICBwdXNoaW50IDEKICAgIHJldHVybgo=","clear":"I3ByYWdtYSB2ZXJzaW9uIDEyCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"DDEbQQAagASg6BhyNhoAjgEAAQAxGYEEEjEYEERCAAgxGRQxGBQQQzFEgQESRIEBQw==","clear":"DIEBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the ContractV0 contract + */ +export type ContractV0Args = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'update()void': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'update()void': [] + } +} + +/** + * The return type for each method + */ +export type ContractV0Returns = { + 'update()void': void +} + +/** + * Defines the types of available calls and state of the ContractV0 smart contract. + */ +export type ContractV0Types = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'update()void' | 'update', { + argsObj: ContractV0Args['obj']['update()void'] + argsTuple: ContractV0Args['tuple']['update()void'] + returns: ContractV0Returns['update()void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type ContractV0Signatures = keyof ContractV0Types['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the ContractV0 smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = ContractV0Types['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the ContractV0 smart contract to the method's return type + */ +export type MethodReturn = ContractV0Types['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type ContractV0CreateCallParams = + | Expand +/** + * Defines supported update method params for this smart contract + */ +export type ContractV0UpdateCallParams = + | Expand & {method: 'update'}> + | Expand & {method: 'update()void'}> +/** + * Defines arguments required for the deploy method. + */ +export type ContractV0DeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: ContractV0CreateCallParams + /** + * Update transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + updateParams?: ContractV0UpdateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the ContractV0 smart contract + */ +export abstract class ContractV0ParamsFactory { + /** + * Gets available update ABI call param factories + */ + static get update() { + return { + _resolveByMethod(params: TParams) { + switch(params.method) { + case 'update': + case 'update()void': + return ContractV0ParamsFactory.update.update(params) + } + throw new Error(`Unknown ' + verb + ' method`) + }, + + /** + * Constructs update ABI call params for the ContractV0 smart contract using the update()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + update(params: CallParams & AppClientCompilationParams): AppClientMethodCallParams & AppClientCompilationParams { + return { + ...params, + method: 'update()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + }, + } + } + +} + +/** + * A factory to create and deploy one or more instance of the ContractV0 smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class ContractV0Factory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `ContractV0Factory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new ContractV0Client(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new ContractV0Client(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the ContractV0 smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: ContractV0DeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + updateParams: params.updateParams?.method ? ContractV0ParamsFactory.update._resolveByMethod(params.updateParams) : params.updateParams ? params.updateParams as (ContractV0UpdateCallParams & { args: Uint8Array[] }) : undefined, + }) + return { result: result.result, appClient: new ContractV0Client(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ContractV0 smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + /** + * Gets available deployUpdate methods + */ + deployUpdate: { + /** + * Updates an existing instance of the ContractV0 smart contract using the update()void ABI method. + * + * @param params The params for the smart contract call + * @returns The deployUpdate params + */ + update: (params: CallParams & AppClientCompilationParams = {args: []}) => { + return this.appFactory.params.deployUpdate(ContractV0ParamsFactory.update.update(params)) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ContractV0 smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ContractV0 smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new ContractV0Client(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the ContractV0 smart contract + */ +export class ContractV0Client { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `ContractV0Client` + * + * @param appClient An `AppClient` instance which has been created with the ContractV0 app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `ContractV0Client` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `ContractV0Client` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new ContractV0Client(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `ContractV0Client` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new ContractV0Client(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available update methods + */ + update: { + /** + * Updates an existing instance of the ContractV0 smart contract using the `update()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The update params + */ + update: (params: CallParams & AppClientCompilationParams & { onComplete?: OnApplicationComplete.UpdateApplication } = {args: []}) => { + return this.appClient.params.update(ContractV0ParamsFactory.update.update(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the ContractV0 smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available update methods + */ + update: { + /** + * Updates an existing instance of the ContractV0 smart contract using the `update()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The update transaction + */ + update: (params: CallParams & AppClientCompilationParams & { onComplete?: OnApplicationComplete.UpdateApplication } = {args: []}) => { + return this.appClient.createTransaction.update(ContractV0ParamsFactory.update.update(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the ContractV0 smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available update methods + */ + update: { + /** + * Updates an existing instance of the ContractV0 smart contract using the `update()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The update result + */ + update: async (params: CallParams & AppClientCompilationParams & SendParams & { onComplete?: OnApplicationComplete.UpdateApplication } = {args: []}) => { + const result = await this.appClient.send.update(ContractV0ParamsFactory.update.update(params)) + return {...result, return: result.return as unknown as (undefined | ContractV0Returns['update()void'])} + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the ContractV0 smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new ContractV0Client(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current ContractV0 app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): ContractV0Composer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + get update() { + return { + update: (params: CallParams & AppClientCompilationParams) => { + promiseChain = promiseChain.then(async () => composer.addAppUpdateMethodCall(await client.params.update.update(params))) + return this + }, + } + }, + /** + * Add a clear state call to the ContractV0 contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as ContractV0Composer + } +} +export type ContractV0Composer = { + /** + * Gets available update methods + */ + readonly update: { + /** + * Updates an existing instance of the ContractV0 smart contract using the update()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + update(params?: CallParams): ContractV0Composer<[...TReturns, ContractV0Returns['update()void'] | undefined]> + } + + /** + * Makes a clear_state call to an existing instance of the ContractV0 smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): ContractV0Composer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): ContractV0Composer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type ContractV0ComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/ContractV1.ts b/examples/p-py/projects/p-py-frontend/src/contracts/ContractV1.ts new file mode 100644 index 0000000..7f5e963 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/ContractV1.ts @@ -0,0 +1,621 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"ContractV1","structs":{},"methods":[{"name":"delete","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["DeleteApplication"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[45],"errorMessage":"can only update if caller expects this to be currently be v1"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDEyCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BVk0xMi9jb250cmFjdC5weTo0MAogICAgLy8gY2xhc3MgQ29udHJhY3RWMShBUkM0Q29udHJhY3QsIGF2bV92ZXJzaW9uPTEyKToKICAgIHR4biBOdW1BcHBBcmdzCiAgICBieiBtYWluX19fYWxnb3B5X2RlZmF1bHRfY3JlYXRlQDUKICAgIHB1c2hieXRlcyAweDI0Mzc4ZDNjIC8vIG1ldGhvZCAiZGVsZXRlKCl2b2lkIgogICAgdHhuYSBBcHBsaWNhdGlvbkFyZ3MgMAogICAgbWF0Y2ggbWFpbl9kZWxldGVfcm91dGVAMwogICAgZXJyCgptYWluX2RlbGV0ZV9yb3V0ZUAzOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FWTTEyL2NvbnRyYWN0LnB5OjQxCiAgICAvLyBAYXJjNC5hYmltZXRob2QoYWxsb3dfYWN0aW9ucz0oIkRlbGV0ZUFwcGxpY2F0aW9uIiwpKQogICAgdHhuIE9uQ29tcGxldGlvbgogICAgcHVzaGludCA1IC8vIERlbGV0ZUFwcGxpY2F0aW9uCiAgICA9PQogICAgdHhuIEFwcGxpY2F0aW9uSUQKICAgICYmCiAgICBhc3NlcnQKICAgIGIgZGVsZXRlCgptYWluX19fYWxnb3B5X2RlZmF1bHRfY3JlYXRlQDU6CiAgICB0eG4gT25Db21wbGV0aW9uCiAgICAhCiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgIQogICAgJiYKICAgIHJldHVybgoKCi8vIHRlc3RzLmFydGlmYWN0cy5BVk0xMi5jb250cmFjdC5Db250cmFjdFYxLmRlbGV0ZVtyb3V0aW5nXSgpIC0+IHZvaWQ6CmRlbGV0ZToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BVk0xMi9jb250cmFjdC5weTo0NAogICAgLy8gVHhuLnJlamVjdF92ZXJzaW9uID09IDIKICAgIHR4biBSZWplY3RWZXJzaW9uCiAgICBwdXNoaW50IDIKICAgID09CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQVZNMTIvY29udHJhY3QucHk6NDMtNDUKICAgIC8vIGFzc2VydCAoCiAgICAvLyAgICAgVHhuLnJlamVjdF92ZXJzaW9uID09IDIKICAgIC8vICksICJjYW4gb25seSB1cGRhdGUgaWYgY2FsbGVyIGV4cGVjdHMgdGhpcyB0byBiZSBjdXJyZW50bHkgYmUgdjEiCiAgICBhc3NlcnQgLy8gY2FuIG9ubHkgdXBkYXRlIGlmIGNhbGxlciBleHBlY3RzIHRoaXMgdG8gYmUgY3VycmVudGx5IGJlIHYxCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQVZNMTIvY29udHJhY3QucHk6NDEKICAgIC8vIEBhcmM0LmFiaW1ldGhvZChhbGxvd19hY3Rpb25zPSgiRGVsZXRlQXBwbGljYXRpb24iLCkpCiAgICBwdXNoaW50IDEKICAgIHJldHVybgo=","clear":"I3ByYWdtYSB2ZXJzaW9uIDEyCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"DDEbQQAagAQkN408NhoAjgEAAQAxGYEFEjEYEERCAAgxGRQxGBQQQzFEgQISRIEBQw==","clear":"DIEBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the ContractV1 contract + */ +export type ContractV1Args = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'delete()void': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'delete()void': [] + } +} + +/** + * The return type for each method + */ +export type ContractV1Returns = { + 'delete()void': void +} + +/** + * Defines the types of available calls and state of the ContractV1 smart contract. + */ +export type ContractV1Types = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'delete()void' | 'delete', { + argsObj: ContractV1Args['obj']['delete()void'] + argsTuple: ContractV1Args['tuple']['delete()void'] + returns: ContractV1Returns['delete()void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type ContractV1Signatures = keyof ContractV1Types['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the ContractV1 smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = ContractV1Types['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the ContractV1 smart contract to the method's return type + */ +export type MethodReturn = ContractV1Types['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type ContractV1CreateCallParams = + | Expand +/** + * Defines supported delete method params for this smart contract + */ +export type ContractV1DeleteCallParams = + | Expand & {method: 'delete'}> + | Expand & {method: 'delete()void'}> +/** + * Defines arguments required for the deploy method. + */ +export type ContractV1DeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: ContractV1CreateCallParams + /** + * Delete transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + deleteParams?: ContractV1DeleteCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the ContractV1 smart contract + */ +export abstract class ContractV1ParamsFactory { + /** + * Gets available delete ABI call param factories + */ + static get delete() { + return { + _resolveByMethod(params: TParams) { + switch(params.method) { + case 'delete': + case 'delete()void': + return ContractV1ParamsFactory.delete.delete(params) + } + throw new Error(`Unknown ' + verb + ' method`) + }, + + /** + * Constructs delete ABI call params for the ContractV1 smart contract using the delete()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + delete(params: CallParams): AppClientMethodCallParams { + return { + ...params, + method: 'delete()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + }, + } + } + +} + +/** + * A factory to create and deploy one or more instance of the ContractV1 smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class ContractV1Factory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `ContractV1Factory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new ContractV1Client(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new ContractV1Client(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the ContractV1 smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: ContractV1DeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + deleteParams: params.deleteParams?.method ? ContractV1ParamsFactory.delete._resolveByMethod(params.deleteParams) : params.deleteParams ? params.deleteParams as (ContractV1DeleteCallParams & { args: Uint8Array[] }) : undefined, + }) + return { result: result.result, appClient: new ContractV1Client(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ContractV1 smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + /** + * Gets available deployDelete methods + */ + deployDelete: { + /** + * Deletes an existing instance of the ContractV1 smart contract using the delete()void ABI method. + * + * @param params The params for the smart contract call + * @returns The deployDelete params + */ + delete: (params: CallParams = {args: []}) => { + return this.appFactory.params.deployDelete(ContractV1ParamsFactory.delete.delete(params)) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ContractV1 smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ContractV1 smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new ContractV1Client(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the ContractV1 smart contract + */ +export class ContractV1Client { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `ContractV1Client` + * + * @param appClient An `AppClient` instance which has been created with the ContractV1 app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `ContractV1Client` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `ContractV1Client` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new ContractV1Client(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `ContractV1Client` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new ContractV1Client(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available delete methods + */ + delete: { + /** + * Deletes an existing instance of the ContractV1 smart contract using the `delete()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The delete params + */ + delete: (params: CallParams & { onComplete?: OnApplicationComplete.DeleteApplication } = {args: []}) => { + return this.appClient.params.delete(ContractV1ParamsFactory.delete.delete(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the ContractV1 smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available delete methods + */ + delete: { + /** + * Deletes an existing instance of the ContractV1 smart contract using the `delete()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The delete transaction + */ + delete: (params: CallParams & { onComplete?: OnApplicationComplete.DeleteApplication } = {args: []}) => { + return this.appClient.createTransaction.delete(ContractV1ParamsFactory.delete.delete(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the ContractV1 smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available delete methods + */ + delete: { + /** + * Deletes an existing instance of the ContractV1 smart contract using the `delete()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The delete result + */ + delete: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.DeleteApplication } = {args: []}) => { + const result = await this.appClient.send.delete(ContractV1ParamsFactory.delete.delete(params)) + return {...result, return: result.return as unknown as (undefined | ContractV1Returns['delete()void'])} + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the ContractV1 smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new ContractV1Client(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current ContractV1 app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): ContractV1Composer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + get delete() { + return { + delete: (params: CallParams) => { + promiseChain = promiseChain.then(async () => composer.addAppDeleteMethodCall(await client.params.delete.delete(params))) + return this + }, + } + }, + /** + * Add a clear state call to the ContractV1 contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as ContractV1Composer + } +} +export type ContractV1Composer = { + /** + * Gets available delete methods + */ + readonly delete: { + /** + * Deletes an existing instance of the ContractV1 smart contract using the delete()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + delete(params?: CallParams): ContractV1Composer<[...TReturns, ContractV1Returns['delete()void'] | undefined]> + } + + /** + * Makes a clear_state call to an existing instance of the ContractV1 smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): ContractV1Composer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): ContractV1Composer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type ContractV1ComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/CryptoOpsContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/CryptoOpsContract.ts new file mode 100644 index 0000000..d63f44a --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/CryptoOpsContract.ts @@ -0,0 +1,1422 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"CryptoOpsContract","structs":{},"methods":[{"name":"verify_sha256","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"pad_size"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_sha3_256","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"pad_size"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_keccak_256","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"pad_size"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_sha512_256","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"pad_size"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ed25519verify","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"},{"type":"byte[]","name":"c"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ed25519verify_bare","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"},{"type":"byte[]","name":"c"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ecdsa_verify_k1","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"},{"type":"byte[]","name":"c"},{"type":"byte[]","name":"d"},{"type":"byte[]","name":"e"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ecdsa_verify_r1","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"},{"type":"byte[]","name":"c"},{"type":"byte[]","name":"d"},{"type":"byte[]","name":"e"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ecdsa_recover_k1","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"},{"type":"byte[]","name":"c"},{"type":"byte[]","name":"d"}],"returns":{"type":"(byte[],byte[])"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ecdsa_recover_r1","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"},{"type":"byte[]","name":"c"},{"type":"byte[]","name":"d"}],"returns":{"type":"(byte[],byte[])"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"desc":"Must fail, AVM does not support Secp256r1 for recover","events":[],"recommendations":{}},{"name":"verify_ecdsa_decompress_k1","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"(byte[],byte[])"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_ecdsa_decompress_r1","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"(byte[],byte[])"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_vrf_verify","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"},{"type":"byte[]","name":"c"}],"returns":{"type":"(byte[],bool)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 3000 4
    bytecblock 0x151f7c75 0x00 0x151f7c750020 0x0004 0x068101
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@20
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x3456c4c3 0xe8442b84 0x65f567aa 0x258455b1 0x35af0f38 0x6582c997 0x6298ffbb 0x3885b54f 0x2164e0bf 0x755b79a5 0xf06bb077 0x133f8ccc 0x2f7c68a9 // method "verify_sha256(byte[],uint64)byte[]", method "verify_sha3_256(byte[],uint64)byte[]", method "verify_keccak_256(byte[],uint64)byte[]", method "verify_sha512_256(byte[],uint64)byte[]", method "verify_ed25519verify(byte[],byte[],byte[])bool", method "verify_ed25519verify_bare(byte[],byte[],byte[])bool", method "verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_decompress_k1(byte[])(byte[],byte[])", method "verify_ecdsa_decompress_r1(byte[])(byte[],byte[])", method "verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)"
    txna ApplicationArgs 0
    match verify_sha256 verify_sha3_256 verify_keccak_256 verify_sha512_256 verify_ed25519verify verify_ed25519verify_bare verify_ecdsa_verify_k1 verify_ecdsa_verify_r1 verify_ecdsa_recover_k1 verify_ecdsa_recover_r1 verify_ecdsa_decompress_k1 verify_ecdsa_decompress_r1 verify_vrf_verify
    err

main___algopy_default_create@20:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// _puya_lib.util.ensure_budget(required_budget: uint64, fee_source: uint64) -> void:
ensure_budget:
    proto 2 0
    frame_dig -2
    pushint 10
    +

ensure_budget_while_top@1:
    frame_dig 0
    global OpcodeBudget
    >
    bz ensure_budget_after_while@6
    itxn_begin
    pushint 6 // appl
    itxn_field TypeEnum
    pushint 5 // DeleteApplication
    itxn_field OnCompletion
    bytec 4 // 0x068101
    itxn_field ApprovalProgram
    bytec 4 // 0x068101
    itxn_field ClearStateProgram
    frame_dig -1
    switch ensure_budget_switch_case_0@3 ensure_budget_switch_case_1@4

ensure_budget_switch_case_next@5:
    itxn_submit
    b ensure_budget_while_top@1

ensure_budget_switch_case_1@4:
    global MinTxnFee
    itxn_field Fee
    b ensure_budget_switch_case_next@5

ensure_budget_switch_case_0@3:
    intc_0 // 0
    itxn_field Fee
    b ensure_budget_switch_case_next@5

ensure_budget_after_while@6:
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha256[routing]() -> void:
verify_sha256:
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:7
    // a = op.bzero(pad_size) + a
    bzero
    swap
    concat
    // tests/artifacts/CryptoOps/contract.py:8
    // result = op.sha256(a)
    sha256
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    bytec_2 // 0x151f7c750020
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha3_256[routing]() -> void:
verify_sha3_256:
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:13
    // a = op.bzero(pad_size) + a
    bzero
    swap
    concat
    // tests/artifacts/CryptoOps/contract.py:14
    // result = op.sha3_256(a)
    sha3_256
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    bytec_2 // 0x151f7c750020
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_keccak_256[routing]() -> void:
verify_keccak_256:
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:19
    // a = op.bzero(pad_size) + a
    bzero
    swap
    concat
    // tests/artifacts/CryptoOps/contract.py:20
    // result = op.keccak256(a)
    keccak256
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    bytec_2 // 0x151f7c750020
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha512_256[routing]() -> void:
verify_sha512_256:
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:25
    // a = op.bzero(pad_size) + a
    bzero
    swap
    concat
    // tests/artifacts/CryptoOps/contract.py:26
    // result = op.sha512_256(a)
    sha512_256
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    bytec_2 // 0x151f7c750020
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify[routing]() -> void:
verify_ed25519verify:
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:31
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:32
    // result = op.ed25519verify(a, b, c)
    ed25519verify
    // tests/artifacts/CryptoOps/contract.py:33
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify_bare[routing]() -> void:
verify_ed25519verify_bare:
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:37
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:38
    // result = op.ed25519verify_bare(a, b, c)
    ed25519verify_bare
    // tests/artifacts/CryptoOps/contract.py:39
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_k1[routing]() -> void:
verify_ecdsa_verify_k1:
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:43
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_2 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:44
    // result_k1 = op.ecdsa_verify(op.ECDSA.Secp256k1, a, b, c, d, e)
    ecdsa_verify Secp256k1
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_r1[routing]() -> void:
verify_ecdsa_verify_r1:
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:49
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_2 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:50
    // result_r1 = op.ecdsa_verify(op.ECDSA.Secp256r1, a, b, c, d, e)
    ecdsa_verify Secp256r1
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_k1[routing]() -> void:
verify_ecdsa_recover_k1:
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:57
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_2 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:58
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256k1, a, b, c, d)
    ecdsa_pk_recover Secp256k1
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_3 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_3 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_r1[routing]() -> void:
verify_ecdsa_recover_r1:
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:67
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_2 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:68
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256r1, a, b, c, d)
    ecdsa_pk_recover Secp256r1
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_3 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_3 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_k1[routing]() -> void:
verify_ecdsa_decompress_k1:
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:72
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:73
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256k1, a)
    ecdsa_pk_decompress Secp256k1
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_3 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_3 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_r1[routing]() -> void:
verify_ecdsa_decompress_r1:
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:77
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:78
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256r1, a)
    ecdsa_pk_decompress Secp256r1
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_3 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_3 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_vrf_verify[routing]() -> void:
verify_vrf_verify:
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:82
    // ensure_budget(5700, OpUpFeeSource.GroupCredit)
    pushint 5700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:83
    // result = op.vrf_verify(op.VrfVerify.VrfAlgorand, a, b, c)
    vrf_verify VrfAlgorand
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 3
    setbit
    pushbytes 0x0003
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyAEAAG4FwQmBQQVH3x1AQAGFR98dQAgAgAEAwaBATEbQQBqMRkURDEYRIINBDRWxMME6EQrhARl9WeqBCWEVbEENa8POARlgsmXBGKY/7sEOIW1TwQhZOC/BHVbeaUE8GuwdwQTP4zMBC98aKk2GgCODQBEAFgAbACAAJQAuQDeAQ4BPgGGAc4CCAJCADEZFDEYFBBDigIAi/6BCgiLADIMDUEAKrGBBrIQgQWyGScEsh4nBLIfi/+NAgALAASzQv/bMgCyAUL/9SKyAUL/74k2GgFXAgA2GgIXr0xQASpMULAjQzYaAVcCADYaAhevTFCYKkxQsCNDNhoBVwIANhoCF69MUAIqTFCwI0M2GgFXAgA2GgIXr0xQAypMULAjQzYaAVcCADYaAlcCADYaA1cCAIHsDiKI/1wEKSJPAlQoTFCwI0M2GgFXAgA2GgJXAgA2GgNXAgCB7A4iiP83hCkiTwJUKExQsCNDNhoBVwIANhoCVwIANhoDVwIANhoEVwIANhoFVwIAJCKI/wgFACkiTwJUKExQsCNDNhoBVwIANhoCVwIANhoDVwIANhoEVwIANhoFVwIAJCKI/tgFASkiTwJUKExQsCNDNhoBVwIANhoCFzYaA1cCADYaBFcCACQiiP6wBwBLARUWVwYCTwJQSRUlCEsCFRZXBgJPA1BMFlcGAitMUE8CUExQKExQsCNDNhoBVwIANhoCFzYaA1cCADYaBFcCACQiiP5oBwFLARUWVwYCTwJQSRUlCEsCFRZXBgJPA1BMFlcGAitMUE8CUExQKExQsCNDNhoBVwIAgbwFIoj+LgYASwEVFlcGAk8CUEkVJQhLAhUWVwYCTwNQTBZXBgIrTFBPAlBMUChMULAjQzYaAVcCAIG8BSKI/fQGAUsBFRZXBgJPAlBJFSUISwIVFlcGAk8DUEwWVwYCK0xQTwJQTFAoTFCwI0M2GgFXAgA2GgJXAgA2GgNXAgCBxCwiiP2u0ABLARUWVwYCTwJQKSJPA1SAAgADTFBMUChMULAjQw==","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the CryptoOpsContract contract + */ +export type CryptoOpsContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_sha256(byte[],uint64)byte[]': { + a: Uint8Array + padSize: bigint | number + } + 'verify_sha3_256(byte[],uint64)byte[]': { + a: Uint8Array + padSize: bigint | number + } + 'verify_keccak_256(byte[],uint64)byte[]': { + a: Uint8Array + padSize: bigint | number + } + 'verify_sha512_256(byte[],uint64)byte[]': { + a: Uint8Array + padSize: bigint | number + } + 'verify_ed25519verify(byte[],byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + c: Uint8Array + } + 'verify_ed25519verify_bare(byte[],byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + c: Uint8Array + } + 'verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + c: Uint8Array + d: Uint8Array + e: Uint8Array + } + 'verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + c: Uint8Array + d: Uint8Array + e: Uint8Array + } + 'verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])': { + a: Uint8Array + b: bigint | number + c: Uint8Array + d: Uint8Array + } + 'verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])': { + a: Uint8Array + b: bigint | number + c: Uint8Array + d: Uint8Array + } + 'verify_ecdsa_decompress_k1(byte[])(byte[],byte[])': { + a: Uint8Array + } + 'verify_ecdsa_decompress_r1(byte[])(byte[],byte[])': { + a: Uint8Array + } + 'verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)': { + a: Uint8Array + b: Uint8Array + c: Uint8Array + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_sha256(byte[],uint64)byte[]': [a: Uint8Array, padSize: bigint | number] + 'verify_sha3_256(byte[],uint64)byte[]': [a: Uint8Array, padSize: bigint | number] + 'verify_keccak_256(byte[],uint64)byte[]': [a: Uint8Array, padSize: bigint | number] + 'verify_sha512_256(byte[],uint64)byte[]': [a: Uint8Array, padSize: bigint | number] + 'verify_ed25519verify(byte[],byte[],byte[])bool': [a: Uint8Array, b: Uint8Array, c: Uint8Array] + 'verify_ed25519verify_bare(byte[],byte[],byte[])bool': [a: Uint8Array, b: Uint8Array, c: Uint8Array] + 'verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool': [a: Uint8Array, b: Uint8Array, c: Uint8Array, d: Uint8Array, e: Uint8Array] + 'verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool': [a: Uint8Array, b: Uint8Array, c: Uint8Array, d: Uint8Array, e: Uint8Array] + 'verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])': [a: Uint8Array, b: bigint | number, c: Uint8Array, d: Uint8Array] + 'verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])': [a: Uint8Array, b: bigint | number, c: Uint8Array, d: Uint8Array] + 'verify_ecdsa_decompress_k1(byte[])(byte[],byte[])': [a: Uint8Array] + 'verify_ecdsa_decompress_r1(byte[])(byte[],byte[])': [a: Uint8Array] + 'verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)': [a: Uint8Array, b: Uint8Array, c: Uint8Array] + } +} + +/** + * The return type for each method + */ +export type CryptoOpsContractReturns = { + 'verify_sha256(byte[],uint64)byte[]': Uint8Array + 'verify_sha3_256(byte[],uint64)byte[]': Uint8Array + 'verify_keccak_256(byte[],uint64)byte[]': Uint8Array + 'verify_sha512_256(byte[],uint64)byte[]': Uint8Array + 'verify_ed25519verify(byte[],byte[],byte[])bool': boolean + 'verify_ed25519verify_bare(byte[],byte[],byte[])bool': boolean + 'verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool': boolean + 'verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool': boolean + 'verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])': [Uint8Array, Uint8Array] + 'verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])': [Uint8Array, Uint8Array] + 'verify_ecdsa_decompress_k1(byte[])(byte[],byte[])': [Uint8Array, Uint8Array] + 'verify_ecdsa_decompress_r1(byte[])(byte[],byte[])': [Uint8Array, Uint8Array] + 'verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)': [Uint8Array, boolean] +} + +/** + * Defines the types of available calls and state of the CryptoOpsContract smart contract. + */ +export type CryptoOpsContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_sha256(byte[],uint64)byte[]' | 'verify_sha256', { + argsObj: CryptoOpsContractArgs['obj']['verify_sha256(byte[],uint64)byte[]'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_sha256(byte[],uint64)byte[]'] + returns: CryptoOpsContractReturns['verify_sha256(byte[],uint64)byte[]'] + }> + & Record<'verify_sha3_256(byte[],uint64)byte[]' | 'verify_sha3_256', { + argsObj: CryptoOpsContractArgs['obj']['verify_sha3_256(byte[],uint64)byte[]'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_sha3_256(byte[],uint64)byte[]'] + returns: CryptoOpsContractReturns['verify_sha3_256(byte[],uint64)byte[]'] + }> + & Record<'verify_keccak_256(byte[],uint64)byte[]' | 'verify_keccak_256', { + argsObj: CryptoOpsContractArgs['obj']['verify_keccak_256(byte[],uint64)byte[]'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_keccak_256(byte[],uint64)byte[]'] + returns: CryptoOpsContractReturns['verify_keccak_256(byte[],uint64)byte[]'] + }> + & Record<'verify_sha512_256(byte[],uint64)byte[]' | 'verify_sha512_256', { + argsObj: CryptoOpsContractArgs['obj']['verify_sha512_256(byte[],uint64)byte[]'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_sha512_256(byte[],uint64)byte[]'] + returns: CryptoOpsContractReturns['verify_sha512_256(byte[],uint64)byte[]'] + }> + & Record<'verify_ed25519verify(byte[],byte[],byte[])bool' | 'verify_ed25519verify', { + argsObj: CryptoOpsContractArgs['obj']['verify_ed25519verify(byte[],byte[],byte[])bool'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_ed25519verify(byte[],byte[],byte[])bool'] + returns: CryptoOpsContractReturns['verify_ed25519verify(byte[],byte[],byte[])bool'] + }> + & Record<'verify_ed25519verify_bare(byte[],byte[],byte[])bool' | 'verify_ed25519verify_bare', { + argsObj: CryptoOpsContractArgs['obj']['verify_ed25519verify_bare(byte[],byte[],byte[])bool'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_ed25519verify_bare(byte[],byte[],byte[])bool'] + returns: CryptoOpsContractReturns['verify_ed25519verify_bare(byte[],byte[],byte[])bool'] + }> + & Record<'verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool' | 'verify_ecdsa_verify_k1', { + argsObj: CryptoOpsContractArgs['obj']['verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool'] + returns: CryptoOpsContractReturns['verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool'] + }> + & Record<'verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool' | 'verify_ecdsa_verify_r1', { + argsObj: CryptoOpsContractArgs['obj']['verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool'] + returns: CryptoOpsContractReturns['verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool'] + }> + & Record<'verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])' | 'verify_ecdsa_recover_k1', { + argsObj: CryptoOpsContractArgs['obj']['verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])'] + returns: CryptoOpsContractReturns['verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])'] + }> + & Record<'verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])' | 'verify_ecdsa_recover_r1', { + argsObj: CryptoOpsContractArgs['obj']['verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])'] + returns: CryptoOpsContractReturns['verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])'] + }> + & Record<'verify_ecdsa_decompress_k1(byte[])(byte[],byte[])' | 'verify_ecdsa_decompress_k1', { + argsObj: CryptoOpsContractArgs['obj']['verify_ecdsa_decompress_k1(byte[])(byte[],byte[])'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_ecdsa_decompress_k1(byte[])(byte[],byte[])'] + returns: CryptoOpsContractReturns['verify_ecdsa_decompress_k1(byte[])(byte[],byte[])'] + }> + & Record<'verify_ecdsa_decompress_r1(byte[])(byte[],byte[])' | 'verify_ecdsa_decompress_r1', { + argsObj: CryptoOpsContractArgs['obj']['verify_ecdsa_decompress_r1(byte[])(byte[],byte[])'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_ecdsa_decompress_r1(byte[])(byte[],byte[])'] + returns: CryptoOpsContractReturns['verify_ecdsa_decompress_r1(byte[])(byte[],byte[])'] + }> + & Record<'verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)' | 'verify_vrf_verify', { + argsObj: CryptoOpsContractArgs['obj']['verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)'] + argsTuple: CryptoOpsContractArgs['tuple']['verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)'] + returns: CryptoOpsContractReturns['verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type CryptoOpsContractSignatures = keyof CryptoOpsContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type CryptoOpsContractNonVoidMethodSignatures = keyof CryptoOpsContractTypes['methods'] extends infer T ? T extends keyof CryptoOpsContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the CryptoOpsContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = CryptoOpsContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the CryptoOpsContract smart contract to the method's return type + */ +export type MethodReturn = CryptoOpsContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type CryptoOpsContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type CryptoOpsContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: CryptoOpsContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the CryptoOpsContract smart contract + */ +export abstract class CryptoOpsContractParamsFactory { + /** + * Constructs a no op call for the verify_sha256(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySha256(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_sha256(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.padSize], + } + } + /** + * Constructs a no op call for the verify_sha3_256(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySha3_256(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_sha3_256(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.padSize], + } + } + /** + * Constructs a no op call for the verify_keccak_256(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyKeccak_256(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_keccak_256(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.padSize], + } + } + /** + * Constructs a no op call for the verify_sha512_256(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySha512_256(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_sha512_256(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.padSize], + } + } + /** + * Constructs a no op call for the verify_ed25519verify(byte[],byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEd25519verify(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ed25519verify(byte[],byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_ed25519verify_bare(byte[],byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEd25519verifyBare(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ed25519verify_bare(byte[],byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEcdsaVerifyK1(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c, params.args.d, params.args.e], + } + } + /** + * Constructs a no op call for the verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEcdsaVerifyR1(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c, params.args.d, params.args.e], + } + } + /** + * Constructs a no op call for the verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[]) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEcdsaRecoverK1(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c, params.args.d], + } + } + /** + * Constructs a no op call for the verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[]) ABI method + * + * Must fail, AVM does not support Secp256r1 for recover + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEcdsaRecoverR1(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c, params.args.d], + } + } + /** + * Constructs a no op call for the verify_ecdsa_decompress_k1(byte[])(byte[],byte[]) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEcdsaDecompressK1(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ecdsa_decompress_k1(byte[])(byte[],byte[])' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_ecdsa_decompress_r1(byte[])(byte[],byte[]) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyEcdsaDecompressR1(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_ecdsa_decompress_r1(byte[])(byte[],byte[])' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_vrf_verify(byte[],byte[],byte[])(byte[],bool) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyVrfVerify(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } +} + +/** + * A factory to create and deploy one or more instance of the CryptoOpsContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class CryptoOpsContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `CryptoOpsContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new CryptoOpsContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new CryptoOpsContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the CryptoOpsContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: CryptoOpsContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new CryptoOpsContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the CryptoOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the CryptoOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the CryptoOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new CryptoOpsContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the CryptoOpsContract smart contract + */ +export class CryptoOpsContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `CryptoOpsContractClient` + * + * @param appClient An `AppClient` instance which has been created with the CryptoOpsContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `CryptoOpsContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `CryptoOpsContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new CryptoOpsContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `CryptoOpsContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new CryptoOpsContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the CryptoOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySha256: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifySha256(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha3_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySha3_256: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifySha3_256(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_keccak_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyKeccak_256: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyKeccak_256(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha512_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySha512_256: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifySha512_256(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ed25519verify(byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEd25519verify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyEd25519verify(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ed25519verify_bare(byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEd25519verifyBare: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyEd25519verifyBare(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEcdsaVerifyK1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyEcdsaVerifyK1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEcdsaVerifyR1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyEcdsaVerifyR1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEcdsaRecoverK1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyEcdsaRecoverK1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])` ABI method. + * + * Must fail, AVM does not support Secp256r1 for recover + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEcdsaRecoverR1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyEcdsaRecoverR1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_decompress_k1(byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEcdsaDecompressK1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyEcdsaDecompressK1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_decompress_r1(byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyEcdsaDecompressR1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyEcdsaDecompressR1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyVrfVerify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(CryptoOpsContractParamsFactory.verifyVrfVerify(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the CryptoOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySha256: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifySha256(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha3_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySha3_256: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifySha3_256(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_keccak_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyKeccak_256: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyKeccak_256(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha512_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySha512_256: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifySha512_256(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ed25519verify(byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEd25519verify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyEd25519verify(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ed25519verify_bare(byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEd25519verifyBare: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyEd25519verifyBare(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEcdsaVerifyK1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyEcdsaVerifyK1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEcdsaVerifyR1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyEcdsaVerifyR1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEcdsaRecoverK1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyEcdsaRecoverK1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])` ABI method. + * + * Must fail, AVM does not support Secp256r1 for recover + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEcdsaRecoverR1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyEcdsaRecoverR1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_decompress_k1(byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEcdsaDecompressK1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyEcdsaDecompressK1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_decompress_r1(byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyEcdsaDecompressR1: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyEcdsaDecompressR1(params)) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyVrfVerify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(CryptoOpsContractParamsFactory.verifyVrfVerify(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the CryptoOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySha256: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifySha256(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_sha256(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha3_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySha3_256: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifySha3_256(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_sha3_256(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_keccak_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyKeccak_256: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyKeccak_256(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_keccak_256(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_sha512_256(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySha512_256: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifySha512_256(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_sha512_256(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ed25519verify(byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEd25519verify: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyEd25519verify(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_ed25519verify(byte[],byte[],byte[])bool'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ed25519verify_bare(byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEd25519verifyBare: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyEd25519verifyBare(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_ed25519verify_bare(byte[],byte[],byte[])bool'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEcdsaVerifyK1: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyEcdsaVerifyK1(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEcdsaVerifyR1: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyEcdsaVerifyR1(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEcdsaRecoverK1: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyEcdsaRecoverK1(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])` ABI method. + * + * Must fail, AVM does not support Secp256r1 for recover + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEcdsaRecoverR1: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyEcdsaRecoverR1(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_decompress_k1(byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEcdsaDecompressK1: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyEcdsaDecompressK1(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_ecdsa_decompress_k1(byte[])(byte[],byte[])'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_ecdsa_decompress_r1(byte[])(byte[],byte[])` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyEcdsaDecompressR1: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyEcdsaDecompressR1(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_ecdsa_decompress_r1(byte[])(byte[],byte[])'])} + }, + + /** + * Makes a call to the CryptoOpsContract smart contract using the `verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyVrfVerify: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(CryptoOpsContractParamsFactory.verifyVrfVerify(params)) + return {...result, return: result.return as unknown as (undefined | CryptoOpsContractReturns['verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new CryptoOpsContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current CryptoOpsContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): CryptoOpsContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_sha256(byte[],uint64)byte[] method call against the CryptoOpsContract contract + */ + verifySha256(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySha256(params))) + return this + }, + /** + * Add a verify_sha3_256(byte[],uint64)byte[] method call against the CryptoOpsContract contract + */ + verifySha3_256(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySha3_256(params))) + return this + }, + /** + * Add a verify_keccak_256(byte[],uint64)byte[] method call against the CryptoOpsContract contract + */ + verifyKeccak_256(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyKeccak_256(params))) + return this + }, + /** + * Add a verify_sha512_256(byte[],uint64)byte[] method call against the CryptoOpsContract contract + */ + verifySha512_256(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySha512_256(params))) + return this + }, + /** + * Add a verify_ed25519verify(byte[],byte[],byte[])bool method call against the CryptoOpsContract contract + */ + verifyEd25519verify(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEd25519verify(params))) + return this + }, + /** + * Add a verify_ed25519verify_bare(byte[],byte[],byte[])bool method call against the CryptoOpsContract contract + */ + verifyEd25519verifyBare(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEd25519verifyBare(params))) + return this + }, + /** + * Add a verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool method call against the CryptoOpsContract contract + */ + verifyEcdsaVerifyK1(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEcdsaVerifyK1(params))) + return this + }, + /** + * Add a verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool method call against the CryptoOpsContract contract + */ + verifyEcdsaVerifyR1(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEcdsaVerifyR1(params))) + return this + }, + /** + * Add a verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[]) method call against the CryptoOpsContract contract + */ + verifyEcdsaRecoverK1(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEcdsaRecoverK1(params))) + return this + }, + /** + * Add a verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[]) method call against the CryptoOpsContract contract + */ + verifyEcdsaRecoverR1(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEcdsaRecoverR1(params))) + return this + }, + /** + * Add a verify_ecdsa_decompress_k1(byte[])(byte[],byte[]) method call against the CryptoOpsContract contract + */ + verifyEcdsaDecompressK1(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEcdsaDecompressK1(params))) + return this + }, + /** + * Add a verify_ecdsa_decompress_r1(byte[])(byte[],byte[]) method call against the CryptoOpsContract contract + */ + verifyEcdsaDecompressR1(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyEcdsaDecompressR1(params))) + return this + }, + /** + * Add a verify_vrf_verify(byte[],byte[],byte[])(byte[],bool) method call against the CryptoOpsContract contract + */ + verifyVrfVerify(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyVrfVerify(params))) + return this + }, + /** + * Add a clear state call to the CryptoOpsContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as CryptoOpsContractComposer + } +} +export type CryptoOpsContractComposer = { + /** + * Calls the verify_sha256(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySha256(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_sha256(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_sha3_256(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySha3_256(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_sha3_256(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_keccak_256(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyKeccak_256(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_keccak_256(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_sha512_256(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySha512_256(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_sha512_256(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_ed25519verify(byte[],byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEd25519verify(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_ed25519verify(byte[],byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_ed25519verify_bare(byte[],byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEd25519verifyBare(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_ed25519verify_bare(byte[],byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEcdsaVerifyK1(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEcdsaVerifyR1(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[]) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEcdsaRecoverK1(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])'] | undefined]> + + /** + * Calls the verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[]) ABI method. + * + * Must fail, AVM does not support Secp256r1 for recover + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEcdsaRecoverR1(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])'] | undefined]> + + /** + * Calls the verify_ecdsa_decompress_k1(byte[])(byte[],byte[]) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEcdsaDecompressK1(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_ecdsa_decompress_k1(byte[])(byte[],byte[])'] | undefined]> + + /** + * Calls the verify_ecdsa_decompress_r1(byte[])(byte[],byte[]) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyEcdsaDecompressR1(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_ecdsa_decompress_r1(byte[])(byte[],byte[])'] | undefined]> + + /** + * Calls the verify_vrf_verify(byte[],byte[],byte[])(byte[],bool) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyVrfVerify(params?: CallParams): CryptoOpsContractComposer<[...TReturns, CryptoOpsContractReturns['verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the CryptoOpsContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): CryptoOpsContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): CryptoOpsContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type CryptoOpsContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/DynamicArrayInitContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/DynamicArrayInitContract.ts new file mode 100644 index 0000000..3ed4087 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/DynamicArrayInitContract.ts @@ -0,0 +1,755 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"DynamicArrayInitContract","structs":{},"methods":[{"name":"test_immutable_array_init","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_immutable_array_init_without_type_generic","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_reference_array_init","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_reference_array_init_without_type_generic","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIGludGNibG9jayAxIDggMyAwCiAgICBieXRlY2Jsb2NrIDB4MDAwMDAwMDAwMDAwMDAwMTAwMDAwMDAwMDAwMDAwMDIwMDAwMDAwMDAwMDAwMDAzCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo0ODAKICAgIC8vIGNsYXNzIER5bmFtaWNBcnJheUluaXRDb250cmFjdChhcmM0LkFSQzRDb250cmFjdCk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9fX2FsZ29weV9kZWZhdWx0X2NyZWF0ZUAxMQogICAgdHhuIE9uQ29tcGxldGlvbgogICAgIQogICAgYXNzZXJ0CiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgYXNzZXJ0CiAgICBwdXNoYnl0ZXNzIDB4ODQzNGJhMmEgMHg2M2FhYmJhMCAweGRiYWYwMzRlIDB4YTlkMTQ1NTQgLy8gbWV0aG9kICJ0ZXN0X2ltbXV0YWJsZV9hcnJheV9pbml0KCl2b2lkIiwgbWV0aG9kICJ0ZXN0X2ltbXV0YWJsZV9hcnJheV9pbml0X3dpdGhvdXRfdHlwZV9nZW5lcmljKCl2b2lkIiwgbWV0aG9kICJ0ZXN0X3JlZmVyZW5jZV9hcnJheV9pbml0KCl2b2lkIiwgbWV0aG9kICJ0ZXN0X3JlZmVyZW5jZV9hcnJheV9pbml0X3dpdGhvdXRfdHlwZV9nZW5lcmljKCl2b2lkIgogICAgdHhuYSBBcHBsaWNhdGlvbkFyZ3MgMAogICAgbWF0Y2ggdGVzdF9pbW11dGFibGVfYXJyYXlfaW5pdCB0ZXN0X2ltbXV0YWJsZV9hcnJheV9pbml0X3dpdGhvdXRfdHlwZV9nZW5lcmljIHRlc3RfcmVmZXJlbmNlX2FycmF5X2luaXQgdGVzdF9yZWZlcmVuY2VfYXJyYXlfaW5pdF93aXRob3V0X3R5cGVfZ2VuZXJpYwogICAgZXJyCgptYWluX19fYWxnb3B5X2RlZmF1bHRfY3JlYXRlQDExOgogICAgdHhuIE9uQ29tcGxldGlvbgogICAgIQogICAgdHhuIEFwcGxpY2F0aW9uSUQKICAgICEKICAgICYmCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuQXJyYXlzLmltbXV0YWJsZS5EeW5hbWljQXJyYXlJbml0Q29udHJhY3QudGVzdF9pbW11dGFibGVfYXJyYXlfaW5pdFtyb3V0aW5nXSgpIC0+IHZvaWQ6CnRlc3RfaW1tdXRhYmxlX2FycmF5X2luaXQ6CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo0ODEKICAgIC8vIEBhcmM0LmFiaW1ldGhvZCgpCiAgICBpbnRjXzAgLy8gMQogICAgcmV0dXJuCgoKLy8gdGVzdHMuYXJ0aWZhY3RzLkFycmF5cy5pbW11dGFibGUuRHluYW1pY0FycmF5SW5pdENvbnRyYWN0LnRlc3RfaW1tdXRhYmxlX2FycmF5X2luaXRfd2l0aG91dF90eXBlX2dlbmVyaWNbcm91dGluZ10oKSAtPiB2b2lkOgp0ZXN0X2ltbXV0YWJsZV9hcnJheV9pbml0X3dpdGhvdXRfdHlwZV9nZW5lcmljOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTAzCiAgICAvLyBAYXJjNC5hYmltZXRob2QoKQogICAgaW50Y18wIC8vIDEKICAgIHJldHVybgoKCi8vIHRlc3RzLmFydGlmYWN0cy5BcnJheXMuaW1tdXRhYmxlLkR5bmFtaWNBcnJheUluaXRDb250cmFjdC50ZXN0X3JlZmVyZW5jZV9hcnJheV9pbml0W3JvdXRpbmddKCkgLT4gdm9pZDoKdGVzdF9yZWZlcmVuY2VfYXJyYXlfaW5pdDoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjUyNwogICAgLy8gYTEgPSBSZWZlcmVuY2VBcnJheVtVSW50NjRdKChVSW50NjQoMSksIFVJbnQ2NCgyKSwgVUludDY0KDMpKSkKICAgIGJ5dGVjXzAgLy8gMHgwMDAwMDAwMDAwMDAwMDAxMDAwMDAwMDAwMDAwMDAwMjAwMDAwMDAwMDAwMDAwMDMKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjUzMAogICAgLy8gYXNzZXJ0IGExLmxlbmd0aCA9PSBhMi5sZW5ndGgKICAgIGR1cG4gMgogICAgbGVuCiAgICBpbnRjXzEgLy8gOAogICAgLwogICAgaW50Y18yIC8vIDMKICAgID09CiAgICBhc3NlcnQKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjUzMQogICAgLy8gYXNzZXJ0IGExWzBdID09IGEyWzBdCiAgICBkdXAKICAgIGludGNfMyAvLyAwCiAgICBleHRyYWN0X3VpbnQ2NAogICAgaW50Y18wIC8vIDEKICAgID09CiAgICBhc3NlcnQKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjUzMgogICAgLy8gYXNzZXJ0IGExWzFdID09IGEyWzFdCiAgICBkdXAKICAgIGludGNfMSAvLyA4CiAgICBleHRyYWN0X3VpbnQ2NAogICAgcHVzaGludCAyCiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo1MzMKICAgIC8vIGFzc2VydCBhMVsyXSA9PSBhMlsyXQogICAgcHVzaGludCAxNgogICAgZXh0cmFjdF91aW50NjQKICAgIGludGNfMiAvLyAzCiAgICA9PQogICAgYXNzZXJ0CiAgICBkdXBuIDIKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjUzNwogICAgLy8gYXNzZXJ0IGExWzBdID09IGEzWzBdCiAgICBpbnRjXzMgLy8gMAogICAgZXh0cmFjdF91aW50NjQKICAgIGludGNfMCAvLyAxCiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo1MzgKICAgIC8vIGFzc2VydCBhMVsxXSA9PSBhM1sxXQogICAgZHVwCiAgICBpbnRjXzEgLy8gOAogICAgZXh0cmFjdF91aW50NjQKICAgIHB1c2hpbnQgMgogICAgPT0KICAgIGFzc2VydAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTM5CiAgICAvLyBhc3NlcnQgYTFbMl0gPT0gYTNbMl0KICAgIHB1c2hpbnQgMTYKICAgIGV4dHJhY3RfdWludDY0CiAgICBpbnRjXzIgLy8gMwogICAgPT0KICAgIGFzc2VydAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTQyCiAgICAvLyBhc3NlcnQgYTEubGVuZ3RoID09IGE0Lmxlbmd0aAogICAgZHVwCiAgICBsZW4KICAgIGludGNfMSAvLyA4CiAgICAvCiAgICBpbnRjXzIgLy8gMwogICAgPT0KICAgIGFzc2VydAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTQzCiAgICAvLyBhc3NlcnQgYTFbMF0gPT0gYTRbMF0KICAgIGR1cAogICAgaW50Y18zIC8vIDAKICAgIGV4dHJhY3RfdWludDY0CiAgICBpbnRjXzAgLy8gMQogICAgPT0KICAgIGFzc2VydAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTQ0CiAgICAvLyBhc3NlcnQgYTFbMV0gPT0gYTRbMV0KICAgIGR1cAogICAgaW50Y18xIC8vIDgKICAgIGV4dHJhY3RfdWludDY0CiAgICBwdXNoaW50IDIKICAgID09CiAgICBhc3NlcnQKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjU0NQogICAgLy8gYXNzZXJ0IGExWzJdID09IGE0WzJdCiAgICBwdXNoaW50IDE2CiAgICBleHRyYWN0X3VpbnQ2NAogICAgaW50Y18yIC8vIDMKICAgID09CiAgICBhc3NlcnQKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjUyNQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIGludGNfMCAvLyAxCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuQXJyYXlzLmltbXV0YWJsZS5EeW5hbWljQXJyYXlJbml0Q29udHJhY3QudGVzdF9yZWZlcmVuY2VfYXJyYXlfaW5pdF93aXRob3V0X3R5cGVfZ2VuZXJpY1tyb3V0aW5nXSgpIC0+IHZvaWQ6CnRlc3RfcmVmZXJlbmNlX2FycmF5X2luaXRfd2l0aG91dF90eXBlX2dlbmVyaWM6CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo1NDkKICAgIC8vIGExID0gUmVmZXJlbmNlQXJyYXkoKFVJbnQ2NCgxKSwgVUludDY0KDIpLCBVSW50NjQoMykpKQogICAgYnl0ZWNfMCAvLyAweDAwMDAwMDAwMDAwMDAwMDEwMDAwMDAwMDAwMDAwMDAyMDAwMDAwMDAwMDAwMDAwMwogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTUyCiAgICAvLyBhc3NlcnQgYTEubGVuZ3RoID09IGEyLmxlbmd0aAogICAgZHVwbiAyCiAgICBsZW4KICAgIGludGNfMSAvLyA4CiAgICAvCiAgICBpbnRjXzIgLy8gMwogICAgPT0KICAgIGFzc2VydAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTUzCiAgICAvLyBhc3NlcnQgYTFbMF0gPT0gYTJbMF0KICAgIGR1cAogICAgaW50Y18zIC8vIDAKICAgIGV4dHJhY3RfdWludDY0CiAgICBpbnRjXzAgLy8gMQogICAgPT0KICAgIGFzc2VydAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTU0CiAgICAvLyBhc3NlcnQgYTFbMV0gPT0gYTJbMV0KICAgIGR1cAogICAgaW50Y18xIC8vIDgKICAgIGV4dHJhY3RfdWludDY0CiAgICBwdXNoaW50IDIKICAgID09CiAgICBhc3NlcnQKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjU1NQogICAgLy8gYXNzZXJ0IGExWzJdID09IGEyWzJdCiAgICBwdXNoaW50IDE2CiAgICBleHRyYWN0X3VpbnQ2NAogICAgaW50Y18yIC8vIDMKICAgID09CiAgICBhc3NlcnQKICAgIGR1cG4gMgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTU5CiAgICAvLyBhc3NlcnQgYTFbMF0gPT0gYTNbMF0KICAgIGludGNfMyAvLyAwCiAgICBleHRyYWN0X3VpbnQ2NAogICAgaW50Y18wIC8vIDEKICAgID09CiAgICBhc3NlcnQKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcnJheXMvaW1tdXRhYmxlLnB5OjU2MAogICAgLy8gYXNzZXJ0IGExWzFdID09IGEzWzFdCiAgICBkdXAKICAgIGludGNfMSAvLyA4CiAgICBleHRyYWN0X3VpbnQ2NAogICAgcHVzaGludCAyCiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo1NjEKICAgIC8vIGFzc2VydCBhMVsyXSA9PSBhM1syXQogICAgcHVzaGludCAxNgogICAgZXh0cmFjdF91aW50NjQKICAgIGludGNfMiAvLyAzCiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo1NjQKICAgIC8vIGFzc2VydCBhMS5sZW5ndGggPT0gYTQubGVuZ3RoCiAgICBkdXAKICAgIGxlbgogICAgaW50Y18xIC8vIDgKICAgIC8KICAgIGludGNfMiAvLyAzCiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo1NjUKICAgIC8vIGFzc2VydCBhMVswXSA9PSBhNFswXQogICAgZHVwCiAgICBpbnRjXzMgLy8gMAogICAgZXh0cmFjdF91aW50NjQKICAgIGludGNfMCAvLyAxCiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQXJyYXlzL2ltbXV0YWJsZS5weTo1NjYKICAgIC8vIGFzc2VydCBhMVsxXSA9PSBhNFsxXQogICAgZHVwCiAgICBpbnRjXzEgLy8gOAogICAgZXh0cmFjdF91aW50NjQKICAgIHB1c2hpbnQgMgogICAgPT0KICAgIGFzc2VydAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTY3CiAgICAvLyBhc3NlcnQgYTFbMl0gPT0gYTRbMl0KICAgIHB1c2hpbnQgMTYKICAgIGV4dHJhY3RfdWludDY0CiAgICBpbnRjXzIgLy8gMwogICAgPT0KICAgIGFzc2VydAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0FycmF5cy9pbW11dGFibGUucHk6NTQ3CiAgICAvLyBAYXJjNC5hYmltZXRob2QoKQogICAgaW50Y18wIC8vIDEKICAgIHJldHVybgo=","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyAEAQgDACYBGAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAzEbQQArMRkURDEYRIIEBIQ0uioEY6q7oATbrwNOBKnRRVQ2GgCOBAAJAAsADQBZADEZFDEYFBBDIkMiQyhHAhUjCiQSREklWyISREkjW4ECEkSBEFskEkRHAiVbIhJESSNbgQISRIEQWyQSREkVIwokEkRJJVsiEkRJI1uBAhJEgRBbJBJEIkMoRwIVIwokEkRJJVsiEkRJI1uBAhJEgRBbJBJERwIlWyISREkjW4ECEkSBEFskEkRJFSMKJBJESSVbIhJESSNbgQISRIEQWyQSRCJD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the DynamicArrayInitContract contract + */ +export type DynamicArrayInitContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'test_immutable_array_init()void': Record + 'test_immutable_array_init_without_type_generic()void': Record + 'test_reference_array_init()void': Record + 'test_reference_array_init_without_type_generic()void': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'test_immutable_array_init()void': [] + 'test_immutable_array_init_without_type_generic()void': [] + 'test_reference_array_init()void': [] + 'test_reference_array_init_without_type_generic()void': [] + } +} + +/** + * The return type for each method + */ +export type DynamicArrayInitContractReturns = { + 'test_immutable_array_init()void': void + 'test_immutable_array_init_without_type_generic()void': void + 'test_reference_array_init()void': void + 'test_reference_array_init_without_type_generic()void': void +} + +/** + * Defines the types of available calls and state of the DynamicArrayInitContract smart contract. + */ +export type DynamicArrayInitContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'test_immutable_array_init()void' | 'test_immutable_array_init', { + argsObj: DynamicArrayInitContractArgs['obj']['test_immutable_array_init()void'] + argsTuple: DynamicArrayInitContractArgs['tuple']['test_immutable_array_init()void'] + returns: DynamicArrayInitContractReturns['test_immutable_array_init()void'] + }> + & Record<'test_immutable_array_init_without_type_generic()void' | 'test_immutable_array_init_without_type_generic', { + argsObj: DynamicArrayInitContractArgs['obj']['test_immutable_array_init_without_type_generic()void'] + argsTuple: DynamicArrayInitContractArgs['tuple']['test_immutable_array_init_without_type_generic()void'] + returns: DynamicArrayInitContractReturns['test_immutable_array_init_without_type_generic()void'] + }> + & Record<'test_reference_array_init()void' | 'test_reference_array_init', { + argsObj: DynamicArrayInitContractArgs['obj']['test_reference_array_init()void'] + argsTuple: DynamicArrayInitContractArgs['tuple']['test_reference_array_init()void'] + returns: DynamicArrayInitContractReturns['test_reference_array_init()void'] + }> + & Record<'test_reference_array_init_without_type_generic()void' | 'test_reference_array_init_without_type_generic', { + argsObj: DynamicArrayInitContractArgs['obj']['test_reference_array_init_without_type_generic()void'] + argsTuple: DynamicArrayInitContractArgs['tuple']['test_reference_array_init_without_type_generic()void'] + returns: DynamicArrayInitContractReturns['test_reference_array_init_without_type_generic()void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type DynamicArrayInitContractSignatures = keyof DynamicArrayInitContractTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the DynamicArrayInitContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = DynamicArrayInitContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the DynamicArrayInitContract smart contract to the method's return type + */ +export type MethodReturn = DynamicArrayInitContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type DynamicArrayInitContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type DynamicArrayInitContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: DynamicArrayInitContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the DynamicArrayInitContract smart contract + */ +export abstract class DynamicArrayInitContractParamsFactory { + /** + * Constructs a no op call for the test_immutable_array_init()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testImmutableArrayInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_immutable_array_init()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_immutable_array_init_without_type_generic()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testImmutableArrayInitWithoutTypeGeneric(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_immutable_array_init_without_type_generic()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_reference_array_init()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testReferenceArrayInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_reference_array_init()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_reference_array_init_without_type_generic()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testReferenceArrayInitWithoutTypeGeneric(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_reference_array_init_without_type_generic()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the DynamicArrayInitContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class DynamicArrayInitContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `DynamicArrayInitContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new DynamicArrayInitContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new DynamicArrayInitContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the DynamicArrayInitContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: DynamicArrayInitContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new DynamicArrayInitContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the DynamicArrayInitContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the DynamicArrayInitContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the DynamicArrayInitContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new DynamicArrayInitContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the DynamicArrayInitContract smart contract + */ +export class DynamicArrayInitContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `DynamicArrayInitContractClient` + * + * @param appClient An `AppClient` instance which has been created with the DynamicArrayInitContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `DynamicArrayInitContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `DynamicArrayInitContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new DynamicArrayInitContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `DynamicArrayInitContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new DynamicArrayInitContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the DynamicArrayInitContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_immutable_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testImmutableArrayInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(DynamicArrayInitContractParamsFactory.testImmutableArrayInit(params)) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_immutable_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testImmutableArrayInitWithoutTypeGeneric: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(DynamicArrayInitContractParamsFactory.testImmutableArrayInitWithoutTypeGeneric(params)) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_reference_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testReferenceArrayInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(DynamicArrayInitContractParamsFactory.testReferenceArrayInit(params)) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_reference_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testReferenceArrayInitWithoutTypeGeneric: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(DynamicArrayInitContractParamsFactory.testReferenceArrayInitWithoutTypeGeneric(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the DynamicArrayInitContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_immutable_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testImmutableArrayInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(DynamicArrayInitContractParamsFactory.testImmutableArrayInit(params)) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_immutable_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testImmutableArrayInitWithoutTypeGeneric: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(DynamicArrayInitContractParamsFactory.testImmutableArrayInitWithoutTypeGeneric(params)) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_reference_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testReferenceArrayInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(DynamicArrayInitContractParamsFactory.testReferenceArrayInit(params)) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_reference_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testReferenceArrayInitWithoutTypeGeneric: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(DynamicArrayInitContractParamsFactory.testReferenceArrayInitWithoutTypeGeneric(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the DynamicArrayInitContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_immutable_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testImmutableArrayInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(DynamicArrayInitContractParamsFactory.testImmutableArrayInit(params)) + return {...result, return: result.return as unknown as (undefined | DynamicArrayInitContractReturns['test_immutable_array_init()void'])} + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_immutable_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testImmutableArrayInitWithoutTypeGeneric: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(DynamicArrayInitContractParamsFactory.testImmutableArrayInitWithoutTypeGeneric(params)) + return {...result, return: result.return as unknown as (undefined | DynamicArrayInitContractReturns['test_immutable_array_init_without_type_generic()void'])} + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_reference_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testReferenceArrayInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(DynamicArrayInitContractParamsFactory.testReferenceArrayInit(params)) + return {...result, return: result.return as unknown as (undefined | DynamicArrayInitContractReturns['test_reference_array_init()void'])} + }, + + /** + * Makes a call to the DynamicArrayInitContract smart contract using the `test_reference_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testReferenceArrayInitWithoutTypeGeneric: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(DynamicArrayInitContractParamsFactory.testReferenceArrayInitWithoutTypeGeneric(params)) + return {...result, return: result.return as unknown as (undefined | DynamicArrayInitContractReturns['test_reference_array_init_without_type_generic()void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new DynamicArrayInitContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current DynamicArrayInitContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): DynamicArrayInitContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a test_immutable_array_init()void method call against the DynamicArrayInitContract contract + */ + testImmutableArrayInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testImmutableArrayInit(params))) + return this + }, + /** + * Add a test_immutable_array_init_without_type_generic()void method call against the DynamicArrayInitContract contract + */ + testImmutableArrayInitWithoutTypeGeneric(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testImmutableArrayInitWithoutTypeGeneric(params))) + return this + }, + /** + * Add a test_reference_array_init()void method call against the DynamicArrayInitContract contract + */ + testReferenceArrayInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testReferenceArrayInit(params))) + return this + }, + /** + * Add a test_reference_array_init_without_type_generic()void method call against the DynamicArrayInitContract contract + */ + testReferenceArrayInitWithoutTypeGeneric(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testReferenceArrayInitWithoutTypeGeneric(params))) + return this + }, + /** + * Add a clear state call to the DynamicArrayInitContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as DynamicArrayInitContractComposer + } +} +export type DynamicArrayInitContractComposer = { + /** + * Calls the test_immutable_array_init()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testImmutableArrayInit(params?: CallParams): DynamicArrayInitContractComposer<[...TReturns, DynamicArrayInitContractReturns['test_immutable_array_init()void'] | undefined]> + + /** + * Calls the test_immutable_array_init_without_type_generic()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testImmutableArrayInitWithoutTypeGeneric(params?: CallParams): DynamicArrayInitContractComposer<[...TReturns, DynamicArrayInitContractReturns['test_immutable_array_init_without_type_generic()void'] | undefined]> + + /** + * Calls the test_reference_array_init()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testReferenceArrayInit(params?: CallParams): DynamicArrayInitContractComposer<[...TReturns, DynamicArrayInitContractReturns['test_reference_array_init()void'] | undefined]> + + /** + * Calls the test_reference_array_init_without_type_generic()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testReferenceArrayInitWithoutTypeGeneric(params?: CallParams): DynamicArrayInitContractComposer<[...TReturns, DynamicArrayInitContractReturns['test_reference_array_init_without_type_generic()void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the DynamicArrayInitContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): DynamicArrayInitContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): DynamicArrayInitContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type DynamicArrayInitContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/DynamicItxnGroup.ts b/examples/p-py/projects/p-py-frontend/src/contracts/DynamicItxnGroup.ts new file mode 100644 index 0000000..8c63c52 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/DynamicItxnGroup.ts @@ -0,0 +1,629 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"DynamicItxnGroup","structs":{},"methods":[{"name":"test_firstly","args":[{"type":"address[]","name":"addresses"},{"type":"pay","name":"funds"},{"type":"uint64","name":"verifier"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_looply","args":[{"type":"address[]","name":"addresses"},{"type":"pay","name":"funds"},{"type":"uint64","name":"verifier"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[85,217],"errorMessage":"Funds must be sent to app"},{"pc":[141,250],"errorMessage":"index access is out of bounds"},{"pc":[89,220],"errorMessage":"invalid array length header"},{"pc":[94,225],"errorMessage":"must provide some accounts"},{"pc":[72,204],"errorMessage":"transaction type is pay"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 32 6
    bytecblock 0x65a9aecc "abc"
    // tests/artifacts/dynamic_itxn_group/contract.py:13
    // class DynamicItxnGroup(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@9
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x17391784 0x3f10aea7 // method "test_firstly(address[],pay,uint64)void", method "test_looply(address[],pay,uint64)void"
    txna ApplicationArgs 0
    match test_firstly test_looply
    err

main___algopy_default_create@9:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.dynamic_itxn_group.contract.DynamicItxnGroup.test_firstly[routing]() -> void:
test_firstly:
    // tests/artifacts/dynamic_itxn_group/contract.py:14
    // @arc4.abimethod
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    btoi
    cover 2
    // tests/artifacts/dynamic_itxn_group/contract.py:18
    // assert funds.receiver == Global.current_application_address, "Funds must be sent to app"
    dup
    gtxns Receiver
    global CurrentApplicationAddress
    ==
    assert // Funds must be sent to app
    // tests/artifacts/dynamic_itxn_group/contract.py:20
    // assert addresses.length, "must provide some accounts"
    dig 1
    intc_1 // 0
    extract_uint16 // on error: invalid array length header
    dup
    cover 3
    dup
    assert // must provide some accounts
    // tests/artifacts/dynamic_itxn_group/contract.py:22
    // share = funds.amount // addresses.length
    swap
    gtxns Amount
    swap
    /
    dup
    cover 2
    // tests/artifacts/dynamic_itxn_group/contract.py:24
    // itxn.Payment(amount=share, receiver=addresses[0].native).stage(begin_group=True)
    itxn_begin
    dig 1
    extract 2 0
    cover 2
    swap
    extract 2 32
    itxn_field Receiver
    itxn_field Amount
    intc_0 // pay
    itxn_field TypeEnum
    intc_1 // 0
    itxn_field Fee
    // tests/artifacts/dynamic_itxn_group/contract.py:26
    // for i in urange(1, addresses.length):
    intc_0 // 1

test_firstly_for_header@2:
    // tests/artifacts/dynamic_itxn_group/contract.py:26
    // for i in urange(1, addresses.length):
    dup
    dig 4
    <
    bz test_firstly_after_for@5
    // tests/artifacts/dynamic_itxn_group/contract.py:27
    // addr = addresses[i]
    dupn 2
    intc_2 // 32
    *
    dig 3
    swap
    intc_2 // 32
    extract3 // on error: index access is out of bounds
    // tests/artifacts/dynamic_itxn_group/contract.py:28
    // itxn.Payment(amount=share, receiver=addr.native).stage()
    itxn_next
    itxn_field Receiver
    dig 3
    itxn_field Amount
    intc_0 // pay
    itxn_field TypeEnum
    intc_1 // 0
    itxn_field Fee
    // tests/artifacts/dynamic_itxn_group/contract.py:26
    // for i in urange(1, addresses.length):
    intc_0 // 1
    +
    bury 1
    b test_firstly_for_header@2

test_firstly_after_for@5:
    // tests/artifacts/dynamic_itxn_group/contract.py:30-32
    // itxn.ApplicationCall(
    //     app_id=verifier.id, app_args=(arc4.arc4_signature("verify()void"),)
    // ).stage()
    itxn_next
    // tests/artifacts/dynamic_itxn_group/contract.py:31
    // app_id=verifier.id, app_args=(arc4.arc4_signature("verify()void"),)
    bytec_0 // method "verify()void"
    itxn_field ApplicationArgs
    dig 4
    itxn_field ApplicationID
    // tests/artifacts/dynamic_itxn_group/contract.py:30
    // itxn.ApplicationCall(
    intc_3 // appl
    itxn_field TypeEnum
    intc_1 // 0
    itxn_field Fee
    // tests/artifacts/dynamic_itxn_group/contract.py:34
    // itxn.AssetConfig(asset_name="abc").stage()
    itxn_next
    bytec_1 // "abc"
    itxn_field ConfigAssetName
    pushint 3 // acfg
    itxn_field TypeEnum
    intc_1 // 0
    itxn_field Fee
    // tests/artifacts/dynamic_itxn_group/contract.py:36
    // itxn.submit_staged()
    itxn_submit
    // tests/artifacts/dynamic_itxn_group/contract.py:14
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.dynamic_itxn_group.contract.DynamicItxnGroup.test_looply[routing]() -> void:
test_looply:
    intc_1 // 0
    // tests/artifacts/dynamic_itxn_group/contract.py:38
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    btoi
    cover 2
    // tests/artifacts/dynamic_itxn_group/contract.py:45
    // assert funds.receiver == Global.current_application_address, "Funds must be sent to app"
    dup
    gtxns Receiver
    global CurrentApplicationAddress
    ==
    assert // Funds must be sent to app
    // tests/artifacts/dynamic_itxn_group/contract.py:47
    // assert addresses.length, "must provide some accounts"
    swap
    intc_1 // 0
    extract_uint16 // on error: invalid array length header
    dup
    cover 2
    dup
    assert // must provide some accounts
    // tests/artifacts/dynamic_itxn_group/contract.py:49
    // share = funds.amount // addresses.length
    swap
    gtxns Amount
    swap
    /
    // tests/artifacts/dynamic_itxn_group/contract.py:51
    // is_first = True
    intc_0 // 1
    intc_1 // 0

test_looply_for_header@2:
    // tests/artifacts/dynamic_itxn_group/contract.py:52
    // for addr in addresses:
    dup
    dig 4
    <
    bz test_looply_after_for@8
    dig 5
    extract 2 0
    dig 1
    intc_2 // 32
    *
    intc_2 // 32
    extract3 // on error: index access is out of bounds
    bury 7
    // tests/artifacts/dynamic_itxn_group/contract.py:54
    // my_txn.stage(begin_group=is_first)
    dig 1
    bz test_looply_itxn_next@5
    itxn_begin

test_looply_after_itxn_begin_next@6:
    dig 6
    itxn_field Receiver
    dig 2
    itxn_field Amount
    // tests/artifacts/dynamic_itxn_group/contract.py:53
    // my_txn = itxn.Payment(amount=share, receiver=addr.native)
    intc_0 // pay
    itxn_field TypeEnum
    intc_1 // 0
    itxn_field Fee
    // tests/artifacts/dynamic_itxn_group/contract.py:55
    // is_first = False
    intc_1 // 0
    bury 2
    dup
    intc_0 // 1
    +
    bury 1
    b test_looply_for_header@2

test_looply_itxn_next@5:
    // tests/artifacts/dynamic_itxn_group/contract.py:54
    // my_txn.stage(begin_group=is_first)
    itxn_next
    b test_looply_after_itxn_begin_next@6

test_looply_after_for@8:
    // tests/artifacts/dynamic_itxn_group/contract.py:57-59
    // itxn.ApplicationCall(
    //     app_id=verifier.id, app_args=(arc4.arc4_signature("verify()void"),)
    // ).stage()
    itxn_next
    // tests/artifacts/dynamic_itxn_group/contract.py:58
    // app_id=verifier.id, app_args=(arc4.arc4_signature("verify()void"),)
    bytec_0 // method "verify()void"
    itxn_field ApplicationArgs
    dig 4
    itxn_field ApplicationID
    // tests/artifacts/dynamic_itxn_group/contract.py:57
    // itxn.ApplicationCall(
    intc_3 // appl
    itxn_field TypeEnum
    intc_1 // 0
    itxn_field Fee
    // tests/artifacts/dynamic_itxn_group/contract.py:61
    // itxn.AssetConfig(asset_name="abc").stage()
    itxn_next
    bytec_1 // "abc"
    itxn_field ConfigAssetName
    pushint 3 // acfg
    itxn_field TypeEnum
    intc_1 // 0
    itxn_field Fee
    // tests/artifacts/dynamic_itxn_group/contract.py:63
    // itxn.submit_staged()
    itxn_submit
    // tests/artifacts/dynamic_itxn_group/contract.py:38
    // @arc4.abimethod
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyAEAQAgBiYCBGWprswDYWJjMRtBAB0xGRREMRhEggIEFzkXhAQ/EK6nNhoAjgIACQCLADEZFDEYFBBDNhoBMRYiCUk4ECISRDYaAhdOAkk4BzIKEkRLASNZSU4DSURMOAhMCklOArFLAVcCAE4CTFcCILIHsggishAjsgEiSUsEDEEAHUcCJAtLA0wkWLayB0sDsggishAjsgEiCEUBQv/ctiiyGksEshglshAjsgG2KbImgQOyECOyAbMiQyM2GgFJMRYiCUk4ECISRDYaAhdOAkk4BzIKEkRMI1lJTgJJREw4CEwKIiNJSwQMQQAwSwVXAgBLASQLJFhFB0sBQQAasUsGsgdLArIIIrIQI7IBI0UCSSIIRQFC/822Qv/jtiiyGksEshglshAjsgG2KbImgQOyECOyAbMiQw==","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the DynamicItxnGroup contract + */ +export type DynamicItxnGroupArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'test_firstly(address[],pay,uint64)void': { + addresses: string[] + funds: AppMethodCallTransactionArgument + verifier: bigint | number + } + 'test_looply(address[],pay,uint64)void': { + addresses: string[] + funds: AppMethodCallTransactionArgument + verifier: bigint | number + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'test_firstly(address[],pay,uint64)void': [addresses: string[], funds: AppMethodCallTransactionArgument, verifier: bigint | number] + 'test_looply(address[],pay,uint64)void': [addresses: string[], funds: AppMethodCallTransactionArgument, verifier: bigint | number] + } +} + +/** + * The return type for each method + */ +export type DynamicItxnGroupReturns = { + 'test_firstly(address[],pay,uint64)void': void + 'test_looply(address[],pay,uint64)void': void +} + +/** + * Defines the types of available calls and state of the DynamicItxnGroup smart contract. + */ +export type DynamicItxnGroupTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'test_firstly(address[],pay,uint64)void' | 'test_firstly', { + argsObj: DynamicItxnGroupArgs['obj']['test_firstly(address[],pay,uint64)void'] + argsTuple: DynamicItxnGroupArgs['tuple']['test_firstly(address[],pay,uint64)void'] + returns: DynamicItxnGroupReturns['test_firstly(address[],pay,uint64)void'] + }> + & Record<'test_looply(address[],pay,uint64)void' | 'test_looply', { + argsObj: DynamicItxnGroupArgs['obj']['test_looply(address[],pay,uint64)void'] + argsTuple: DynamicItxnGroupArgs['tuple']['test_looply(address[],pay,uint64)void'] + returns: DynamicItxnGroupReturns['test_looply(address[],pay,uint64)void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type DynamicItxnGroupSignatures = keyof DynamicItxnGroupTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the DynamicItxnGroup smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = DynamicItxnGroupTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the DynamicItxnGroup smart contract to the method's return type + */ +export type MethodReturn = DynamicItxnGroupTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type DynamicItxnGroupCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type DynamicItxnGroupDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: DynamicItxnGroupCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the DynamicItxnGroup smart contract + */ +export abstract class DynamicItxnGroupParamsFactory { + /** + * Constructs a no op call for the test_firstly(address[],pay,uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testFirstly(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_firstly(address[],pay,uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.addresses, params.args.funds, params.args.verifier], + } + } + /** + * Constructs a no op call for the test_looply(address[],pay,uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testLooply(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_looply(address[],pay,uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.addresses, params.args.funds, params.args.verifier], + } + } +} + +/** + * A factory to create and deploy one or more instance of the DynamicItxnGroup smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class DynamicItxnGroupFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `DynamicItxnGroupFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new DynamicItxnGroupClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new DynamicItxnGroupClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the DynamicItxnGroup smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: DynamicItxnGroupDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new DynamicItxnGroupClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the DynamicItxnGroup smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the DynamicItxnGroup smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the DynamicItxnGroup smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new DynamicItxnGroupClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the DynamicItxnGroup smart contract + */ +export class DynamicItxnGroupClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `DynamicItxnGroupClient` + * + * @param appClient An `AppClient` instance which has been created with the DynamicItxnGroup app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `DynamicItxnGroupClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `DynamicItxnGroupClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new DynamicItxnGroupClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `DynamicItxnGroupClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new DynamicItxnGroupClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the DynamicItxnGroup smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the DynamicItxnGroup smart contract using the `test_firstly(address[],pay,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testFirstly: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(DynamicItxnGroupParamsFactory.testFirstly(params)) + }, + + /** + * Makes a call to the DynamicItxnGroup smart contract using the `test_looply(address[],pay,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testLooply: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(DynamicItxnGroupParamsFactory.testLooply(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the DynamicItxnGroup smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the DynamicItxnGroup smart contract using the `test_firstly(address[],pay,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testFirstly: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(DynamicItxnGroupParamsFactory.testFirstly(params)) + }, + + /** + * Makes a call to the DynamicItxnGroup smart contract using the `test_looply(address[],pay,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testLooply: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(DynamicItxnGroupParamsFactory.testLooply(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the DynamicItxnGroup smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the DynamicItxnGroup smart contract using the `test_firstly(address[],pay,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testFirstly: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(DynamicItxnGroupParamsFactory.testFirstly(params)) + return {...result, return: result.return as unknown as (undefined | DynamicItxnGroupReturns['test_firstly(address[],pay,uint64)void'])} + }, + + /** + * Makes a call to the DynamicItxnGroup smart contract using the `test_looply(address[],pay,uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testLooply: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(DynamicItxnGroupParamsFactory.testLooply(params)) + return {...result, return: result.return as unknown as (undefined | DynamicItxnGroupReturns['test_looply(address[],pay,uint64)void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new DynamicItxnGroupClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current DynamicItxnGroup app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): DynamicItxnGroupComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a test_firstly(address[],pay,uint64)void method call against the DynamicItxnGroup contract + */ + testFirstly(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testFirstly(params))) + return this + }, + /** + * Add a test_looply(address[],pay,uint64)void method call against the DynamicItxnGroup contract + */ + testLooply(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testLooply(params))) + return this + }, + /** + * Add a clear state call to the DynamicItxnGroup contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as DynamicItxnGroupComposer + } +} +export type DynamicItxnGroupComposer = { + /** + * Calls the test_firstly(address[],pay,uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testFirstly(params?: CallParams): DynamicItxnGroupComposer<[...TReturns, DynamicItxnGroupReturns['test_firstly(address[],pay,uint64)void'] | undefined]> + + /** + * Calls the test_looply(address[],pay,uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testLooply(params?: CallParams): DynamicItxnGroupComposer<[...TReturns, DynamicItxnGroupReturns['test_looply(address[],pay,uint64)void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the DynamicItxnGroup smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): DynamicItxnGroupComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): DynamicItxnGroupComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type DynamicItxnGroupComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/GlobalStateContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/GlobalStateContract.ts new file mode 100644 index 0000000..0d69d22 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/GlobalStateContract.ts @@ -0,0 +1,2649 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"GlobalStateContract","structs":{},"methods":[{"name":"get_implicit_key_arc4_uint","args":[],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_string","args":[],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_byte","args":[],"returns":{"type":"byte"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_bool","args":[],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_address","args":[],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_uint128","args":[],"returns":{"type":"uint128"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_dynamic_bytes","args":[],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_tuple","args":[],"returns":{"type":"(uint64,byte[],bool)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_uint","args":[],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_string","args":[],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_byte","args":[],"returns":{"type":"byte"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_bool","args":[],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_address","args":[],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_uint128","args":[],"returns":{"type":"uint128"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_dynamic_bytes","args":[],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_implicit_key_arc4_uint","args":[{"type":"uint64","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_implicit_key_arc4_string","args":[{"type":"string","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_implicit_key_arc4_byte","args":[{"type":"byte","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_implicit_key_arc4_bool","args":[{"type":"bool","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_implicit_key_arc4_address","args":[{"type":"address","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_implicit_key_arc4_uint128","args":[{"type":"uint128","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_implicit_key_arc4_dynamic_bytes","args":[{"type":"byte[]","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_implicit_key_tuple","args":[{"type":"(uint64,byte[],bool)","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_arc4_uint","args":[{"type":"uint64","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_arc4_string","args":[{"type":"string","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_arc4_byte","args":[{"type":"byte","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_arc4_bool","args":[{"type":"bool","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_arc4_address","args":[{"type":"address","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_arc4_uint128","args":[{"type":"uint128","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"set_arc4_dynamic_bytes","args":[{"type":"byte[]","name":"value"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":15},"local":{"ints":0,"bytes":0}},"keys":{"global":{"implicit_key_arc4_uint":{"keyType":"AVMString","valueType":"uint64","key":"aW1wbGljaXRfa2V5X2FyYzRfdWludA=="},"implicit_key_arc4_string":{"keyType":"AVMString","valueType":"string","key":"aW1wbGljaXRfa2V5X2FyYzRfc3RyaW5n"},"implicit_key_arc4_byte":{"keyType":"AVMString","valueType":"byte","key":"aW1wbGljaXRfa2V5X2FyYzRfYnl0ZQ=="},"implicit_key_arc4_bool":{"keyType":"AVMString","valueType":"bool","key":"aW1wbGljaXRfa2V5X2FyYzRfYm9vbA=="},"implicit_key_arc4_address":{"keyType":"AVMString","valueType":"address","key":"aW1wbGljaXRfa2V5X2FyYzRfYWRkcmVzcw=="},"implicit_key_arc4_uint128":{"keyType":"AVMString","valueType":"uint128","key":"aW1wbGljaXRfa2V5X2FyYzRfdWludDEyOA=="},"implicit_key_arc4_dynamic_bytes":{"keyType":"AVMString","valueType":"byte[]","key":"aW1wbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlcw=="},"implicit_key_tuple":{"keyType":"AVMString","valueType":"(uint64,byte[],bool)","key":"aW1wbGljaXRfa2V5X3R1cGxl"},"arc4_uint":{"keyType":"AVMString","valueType":"uint64","key":"ZXhwbGljaXRfa2V5X2FyYzRfdWludA=="},"arc4_string":{"keyType":"AVMString","valueType":"string","key":"ZXhwbGljaXRfa2V5X2FyYzRfc3RyaW5n"},"arc4_byte":{"keyType":"AVMString","valueType":"byte","key":"ZXhwbGljaXRfa2V5X2FyYzRfYnl0ZQ=="},"arc4_bool":{"keyType":"AVMString","valueType":"bool","key":"ZXhwbGljaXRfa2V5X2FyYzRfYm9vbA=="},"arc4_address":{"keyType":"AVMString","valueType":"address","key":"ZXhwbGljaXRfa2V5X2FyYzRfYWRkcmVzcw=="},"arc4_uint128":{"keyType":"AVMString","valueType":"uint128","key":"ZXhwbGljaXRfa2V5X2FyYzRfdWludDEyOA=="},"arc4_dynamic_bytes":{"keyType":"AVMString","valueType":"byte[]","key":"ZXhwbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlcw=="}},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[906],"errorMessage":"check self.arc4_address exists"},{"pc":[895],"errorMessage":"check self.arc4_bool exists"},{"pc":[884],"errorMessage":"check self.arc4_byte exists"},{"pc":[928],"errorMessage":"check self.arc4_dynamic_bytes exists"},{"pc":[873],"errorMessage":"check self.arc4_string exists"},{"pc":[862],"errorMessage":"check self.arc4_uint exists"},{"pc":[917],"errorMessage":"check self.arc4_uint128 exists"},{"pc":[818],"errorMessage":"check self.implicit_key_arc4_address exists"},{"pc":[807],"errorMessage":"check self.implicit_key_arc4_bool exists"},{"pc":[796],"errorMessage":"check self.implicit_key_arc4_byte exists"},{"pc":[840],"errorMessage":"check self.implicit_key_arc4_dynamic_bytes exists"},{"pc":[786],"errorMessage":"check self.implicit_key_arc4_string exists"},{"pc":[776],"errorMessage":"check self.implicit_key_arc4_uint exists"},{"pc":[829],"errorMessage":"check self.implicit_key_arc4_uint128 exists"},{"pc":[851],"errorMessage":"check self.implicit_key_tuple exists"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75 "implicit_key_arc4_uint" "implicit_key_arc4_string" "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" "implicit_key_arc4_dynamic_bytes" "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes" 0x0000000000000539 0x000548656c6c6f 0x00000010000000000000000000000000 0x000d64796e616d6963206279746573
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateOps/contract.py:515-516
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    bytec_1 // "implicit_key_arc4_uint"
    bytec 16 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:517
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec_2 // "implicit_key_arc4_string"
    bytec 17 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:518
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    bytec_3 // "implicit_key_arc4_byte"
    pushbytes 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    bytec 4 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:520
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    bytec 5 // "implicit_key_arc4_address"
    global CreatorAddress
    app_global_put
    // tests/artifacts/StateOps/contract.py:521
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    bytec 6 // "implicit_key_arc4_uint128"
    bytec 18 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 7 // "implicit_key_arc4_dynamic_bytes"
    bytec 19 // 0x000d64796e616d6963206279746573
    app_global_put
    // tests/artifacts/StateOps/contract.py:523
    // self.implicit_key_tuple = GlobalState((UInt64(10), Bytes(b"test"), False))
    bytec 8 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_global_put
    // tests/artifacts/StateOps/contract.py:525-526
    // # Explicit key state variables
    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
    bytec 9 // "explicit_key_arc4_uint"
    bytec 16 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    bytec 10 // "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:517
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec 17 // 0x000548656c6c6f
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    app_global_put
    // tests/artifacts/StateOps/contract.py:528
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    bytec 11 // "explicit_key_arc4_byte"
    pushbytes 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    bytec 12 // "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    pushbytes 0x80
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    app_global_put
    // tests/artifacts/StateOps/contract.py:531
    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    bytec 13 // "explicit_key_arc4_address"
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:530-532
    // self.arc4_address = GlobalState(
    //     arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    // )
    app_global_put
    // tests/artifacts/StateOps/contract.py:533
    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
    bytec 14 // "explicit_key_arc4_uint128"
    bytec 18 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:535
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    bytec 15 // "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 19 // 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:534-536
    // self.arc4_dynamic_bytes = GlobalState(
    //     arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    // )
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@39
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x1cc966ee 0x2367cd4b 0x69128e90 0x68d590e2 0x44ef0681 0x1cd294ec 0xaac8ecb1 0x166c6afd 0x3cc3bb7b 0x9a6946ad 0xded75033 0x66279e93 0x096e927b 0x97531fbc 0x6ea3f996 0xa7f4f402 0xaaddcc4c 0x5ec3116d 0x20f56eee 0x1c149a43 0xa575ac7d 0x87f0869b 0x461afc6d 0x048116ea 0x30e34a93 0xd2e646ef 0xe674a270 0xa87e540d 0x720a3ca0 0x257708f7 // method "get_implicit_key_arc4_uint()uint64", method "get_implicit_key_arc4_string()string", method "get_implicit_key_arc4_byte()byte", method "get_implicit_key_arc4_bool()bool", method "get_implicit_key_arc4_address()address", method "get_implicit_key_arc4_uint128()uint128", method "get_implicit_key_arc4_dynamic_bytes()byte[]", method "get_implicit_key_tuple()(uint64,byte[],bool)", method "get_arc4_uint()uint64", method "get_arc4_string()string", method "get_arc4_byte()byte", method "get_arc4_bool()bool", method "get_arc4_address()address", method "get_arc4_uint128()uint128", method "get_arc4_dynamic_bytes()byte[]", method "set_implicit_key_arc4_uint(uint64)void", method "set_implicit_key_arc4_string(string)void", method "set_implicit_key_arc4_byte(byte)void", method "set_implicit_key_arc4_bool(bool)void", method "set_implicit_key_arc4_address(address)void", method "set_implicit_key_arc4_uint128(uint128)void", method "set_implicit_key_arc4_dynamic_bytes(byte[])void", method "set_implicit_key_tuple((uint64,byte[],bool))void", method "set_arc4_uint(uint64)void", method "set_arc4_string(string)void", method "set_arc4_byte(byte)void", method "set_arc4_bool(bool)void", method "set_arc4_address(address)void", method "set_arc4_uint128(uint128)void", method "set_arc4_dynamic_bytes(byte[])void"
    txna ApplicationArgs 0
    match get_implicit_key_arc4_uint get_implicit_key_arc4_string get_implicit_key_arc4_byte get_implicit_key_arc4_bool get_implicit_key_arc4_address get_implicit_key_arc4_uint128 get_implicit_key_arc4_dynamic_bytes get_implicit_key_tuple get_arc4_uint get_arc4_string get_arc4_byte get_arc4_bool get_arc4_address get_arc4_uint128 get_arc4_dynamic_bytes set_implicit_key_arc4_uint set_implicit_key_arc4_string set_implicit_key_arc4_byte set_implicit_key_arc4_bool set_implicit_key_arc4_address set_implicit_key_arc4_uint128 set_implicit_key_arc4_dynamic_bytes set_implicit_key_tuple set_arc4_uint set_arc4_string set_arc4_byte set_arc4_bool set_arc4_address set_arc4_uint128 set_arc4_dynamic_bytes
    err

main___algopy_default_create@39:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint[routing]() -> void:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:541
    // return self.implicit_key_arc4_uint.value
    intc_1 // 0
    bytec_1 // "implicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint exists
    // tests/artifacts/StateOps/contract.py:538-539
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_string[routing]() -> void:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:545
    // return self.implicit_key_arc4_string.value
    intc_1 // 0
    bytec_2 // "implicit_key_arc4_string"
    app_global_get_ex
    assert // check self.implicit_key_arc4_string exists
    // tests/artifacts/StateOps/contract.py:543
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_byte[routing]() -> void:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:549
    // return self.implicit_key_arc4_byte.value
    intc_1 // 0
    bytec_3 // "implicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.implicit_key_arc4_byte exists
    // tests/artifacts/StateOps/contract.py:547
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_bool[routing]() -> void:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:553
    // return self.implicit_key_arc4_bool.value
    intc_1 // 0
    bytec 4 // "implicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.implicit_key_arc4_bool exists
    // tests/artifacts/StateOps/contract.py:551
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_address[routing]() -> void:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:557
    // return self.implicit_key_arc4_address.value
    intc_1 // 0
    bytec 5 // "implicit_key_arc4_address"
    app_global_get_ex
    assert // check self.implicit_key_arc4_address exists
    // tests/artifacts/StateOps/contract.py:555
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint128[routing]() -> void:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:561
    // return self.implicit_key_arc4_uint128.value
    intc_1 // 0
    bytec 6 // "implicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint128 exists
    // tests/artifacts/StateOps/contract.py:559
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_dynamic_bytes[routing]() -> void:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:565
    // return self.implicit_key_arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 7 // "implicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists
    // tests/artifacts/StateOps/contract.py:563
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_tuple[routing]() -> void:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:569
    // return self.implicit_key_tuple.value
    intc_1 // 0
    bytec 8 // "implicit_key_tuple"
    app_global_get_ex
    assert // check self.implicit_key_tuple exists
    // tests/artifacts/StateOps/contract.py:567
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint[routing]() -> void:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:574
    // return self.arc4_uint.value
    intc_1 // 0
    bytec 9 // "explicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.arc4_uint exists
    // tests/artifacts/StateOps/contract.py:571-572
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_string[routing]() -> void:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:578
    // return self.arc4_string.value
    intc_1 // 0
    bytec 10 // "explicit_key_arc4_string"
    app_global_get_ex
    assert // check self.arc4_string exists
    // tests/artifacts/StateOps/contract.py:576
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_byte[routing]() -> void:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:582
    // return self.arc4_byte.value
    intc_1 // 0
    bytec 11 // "explicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.arc4_byte exists
    // tests/artifacts/StateOps/contract.py:580
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_bool[routing]() -> void:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:586
    // return self.arc4_bool.value
    intc_1 // 0
    bytec 12 // "explicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.arc4_bool exists
    // tests/artifacts/StateOps/contract.py:584
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_address[routing]() -> void:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:590
    // return self.arc4_address.value
    intc_1 // 0
    bytec 13 // "explicit_key_arc4_address"
    app_global_get_ex
    assert // check self.arc4_address exists
    // tests/artifacts/StateOps/contract.py:588
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint128[routing]() -> void:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:594
    // return self.arc4_uint128.value
    intc_1 // 0
    bytec 14 // "explicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.arc4_uint128 exists
    // tests/artifacts/StateOps/contract.py:592
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_dynamic_bytes[routing]() -> void:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:598
    // return self.arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 15 // "explicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.arc4_dynamic_bytes exists
    // tests/artifacts/StateOps/contract.py:596
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint[routing]() -> void:
set_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:603
    // self.implicit_key_arc4_uint.value = value
    bytec_1 // "implicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:603
    // self.implicit_key_arc4_uint.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_string[routing]() -> void:
set_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:607
    // self.implicit_key_arc4_string.value = value
    bytec_2 // "implicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:607
    // self.implicit_key_arc4_string.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_byte[routing]() -> void:
set_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:611
    // self.implicit_key_arc4_byte.value = value
    bytec_3 // "implicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:611
    // self.implicit_key_arc4_byte.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_bool[routing]() -> void:
set_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:615
    // self.implicit_key_arc4_bool.value = value
    bytec 4 // "implicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:615
    // self.implicit_key_arc4_bool.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_address[routing]() -> void:
set_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:619
    // self.implicit_key_arc4_address.value = value
    bytec 5 // "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:619
    // self.implicit_key_arc4_address.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint128[routing]() -> void:
set_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:623
    // self.implicit_key_arc4_uint128.value = value
    bytec 6 // "implicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:623
    // self.implicit_key_arc4_uint128.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_dynamic_bytes[routing]() -> void:
set_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:627
    // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
    bytec 7 // "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:627
    // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
    app_global_put
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_tuple[routing]() -> void:
set_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:631
    // self.implicit_key_tuple.value = value
    bytec 8 // "implicit_key_tuple"
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:631
    // self.implicit_key_tuple.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint[routing]() -> void:
set_arc4_uint:
    // tests/artifacts/StateOps/contract.py:636
    // self.arc4_uint.value = value
    bytec 9 // "explicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:636
    // self.arc4_uint.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_string[routing]() -> void:
set_arc4_string:
    // tests/artifacts/StateOps/contract.py:640
    // self.arc4_string.value = value
    bytec 10 // "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:640
    // self.arc4_string.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_byte[routing]() -> void:
set_arc4_byte:
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_byte.value = value
    bytec 11 // "explicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_byte.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_bool[routing]() -> void:
set_arc4_bool:
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_bool.value = value
    bytec 12 // "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_bool.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_address[routing]() -> void:
set_arc4_address:
    // tests/artifacts/StateOps/contract.py:652
    // self.arc4_address.value = value
    bytec 13 // "explicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:652
    // self.arc4_address.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint128[routing]() -> void:
set_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:656
    // self.arc4_uint128.value = value
    bytec 14 // "explicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:656
    // self.arc4_uint128.value = value
    app_global_put
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_dynamic_bytes[routing]() -> void:
set_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:660
    // self.arc4_dynamic_bytes.value = value.copy()
    bytec 15 // "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:660
    // self.arc4_dynamic_bytes.value = value.copy()
    app_global_put
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyACAQAmFAQVH3x1FmltcGxpY2l0X2tleV9hcmM0X3VpbnQYaW1wbGljaXRfa2V5X2FyYzRfc3RyaW5nFmltcGxpY2l0X2tleV9hcmM0X2J5dGUWaW1wbGljaXRfa2V5X2FyYzRfYm9vbBlpbXBsaWNpdF9rZXlfYXJjNF9hZGRyZXNzGWltcGxpY2l0X2tleV9hcmM0X3VpbnQxMjgfaW1wbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlcxJpbXBsaWNpdF9rZXlfdHVwbGUWZXhwbGljaXRfa2V5X2FyYzRfdWludBhleHBsaWNpdF9rZXlfYXJjNF9zdHJpbmcWZXhwbGljaXRfa2V5X2FyYzRfYnl0ZRZleHBsaWNpdF9rZXlfYXJjNF9ib29sGWV4cGxpY2l0X2tleV9hcmM0X2FkZHJlc3MZZXhwbGljaXRfa2V5X2FyYzRfdWludDEyOB9leHBsaWNpdF9rZXlfYXJjNF9keW5hbWljX2J5dGVzCAAAAAAAAAU5BwAFSGVsbG8QAAAAEAAAAAAAAAAAAAAAAA8ADWR5bmFtaWMgYnl0ZXMxGEAAXSknEGcqJxFnK4ABAGcnBIABgGcnBTIJZycGJxJnJwcnE2cnCIARAAAAAAAAAAoACwAABHRlc3RnJwknEGcnCicRZycLgAEAZycMgAGAZycNMglnJw4nEmcnDycTZzEbQQDhMRkURDEYRIIeBBzJZu4EI2fNSwRpEo6QBGjVkOIERO8GgQQc0pTsBKrI7LEEFmxq/QQ8w7t7BJppRq0E3tdQMwRmJ56TBAluknsEl1MfvARuo/mWBKf09AIEqt3MTARewxFtBCD1bu4EHBSaQwSldax9BIfwhpsERhr8bQQEgRbqBDDjSpME0uZG7wTmdKJwBKh+VA0Ecgo8oAQldwj3NhoAjh4ACQATAB0AJwAyAD0ASABTAF4AaQB0AH8AigCVAKAAqwCyALkAwADIANAA2ADgAOgA8AD4AQABCAEQARgAMRkUMRgUEEMjKWVEKExQsCJDIyplRChMULAiQyMrZUQoTFCwIkMjJwRlRChMULAiQyMnBWVEKExQsCJDIycGZUQoTFCwIkMjJwdlRChMULAiQyMnCGVEKExQsCJDIycJZUQoTFCwIkMjJwplRChMULAiQyMnC2VEKExQsCJDIycMZUQoTFCwIkMjJw1lRChMULAiQyMnDmVEKExQsCJDIycPZUQoTFCwIkMpNhoBZyJDKjYaAWciQys2GgFnIkMnBDYaAWciQycFNhoBZyJDJwY2GgFnIkMnBzYaAWciQycINhoBZyJDJwk2GgFnIkMnCjYaAWciQycLNhoBZyJDJww2GgFnIkMnDTYaAWciQycONhoBZyJDJw82GgFnIkM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the GlobalStateContract contract + */ +export type GlobalStateContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'get_implicit_key_arc4_uint()uint64': Record + 'get_implicit_key_arc4_string()string': Record + 'get_implicit_key_arc4_byte()byte': Record + 'get_implicit_key_arc4_bool()bool': Record + 'get_implicit_key_arc4_address()address': Record + 'get_implicit_key_arc4_uint128()uint128': Record + 'get_implicit_key_arc4_dynamic_bytes()byte[]': Record + 'get_implicit_key_tuple()(uint64,byte[],bool)': Record + 'get_arc4_uint()uint64': Record + 'get_arc4_string()string': Record + 'get_arc4_byte()byte': Record + 'get_arc4_bool()bool': Record + 'get_arc4_address()address': Record + 'get_arc4_uint128()uint128': Record + 'get_arc4_dynamic_bytes()byte[]': Record + 'set_implicit_key_arc4_uint(uint64)void': { + value: bigint | number + } + 'set_implicit_key_arc4_string(string)void': { + value: string + } + 'set_implicit_key_arc4_byte(byte)void': { + value: number + } + 'set_implicit_key_arc4_bool(bool)void': { + value: boolean + } + 'set_implicit_key_arc4_address(address)void': { + value: string + } + 'set_implicit_key_arc4_uint128(uint128)void': { + value: bigint | number + } + 'set_implicit_key_arc4_dynamic_bytes(byte[])void': { + value: Uint8Array + } + 'set_implicit_key_tuple((uint64,byte[],bool))void': { + value: [bigint | number, Uint8Array, boolean] + } + 'set_arc4_uint(uint64)void': { + value: bigint | number + } + 'set_arc4_string(string)void': { + value: string + } + 'set_arc4_byte(byte)void': { + value: number + } + 'set_arc4_bool(bool)void': { + value: boolean + } + 'set_arc4_address(address)void': { + value: string + } + 'set_arc4_uint128(uint128)void': { + value: bigint | number + } + 'set_arc4_dynamic_bytes(byte[])void': { + value: Uint8Array + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'get_implicit_key_arc4_uint()uint64': [] + 'get_implicit_key_arc4_string()string': [] + 'get_implicit_key_arc4_byte()byte': [] + 'get_implicit_key_arc4_bool()bool': [] + 'get_implicit_key_arc4_address()address': [] + 'get_implicit_key_arc4_uint128()uint128': [] + 'get_implicit_key_arc4_dynamic_bytes()byte[]': [] + 'get_implicit_key_tuple()(uint64,byte[],bool)': [] + 'get_arc4_uint()uint64': [] + 'get_arc4_string()string': [] + 'get_arc4_byte()byte': [] + 'get_arc4_bool()bool': [] + 'get_arc4_address()address': [] + 'get_arc4_uint128()uint128': [] + 'get_arc4_dynamic_bytes()byte[]': [] + 'set_implicit_key_arc4_uint(uint64)void': [value: bigint | number] + 'set_implicit_key_arc4_string(string)void': [value: string] + 'set_implicit_key_arc4_byte(byte)void': [value: number] + 'set_implicit_key_arc4_bool(bool)void': [value: boolean] + 'set_implicit_key_arc4_address(address)void': [value: string] + 'set_implicit_key_arc4_uint128(uint128)void': [value: bigint | number] + 'set_implicit_key_arc4_dynamic_bytes(byte[])void': [value: Uint8Array] + 'set_implicit_key_tuple((uint64,byte[],bool))void': [value: [bigint | number, Uint8Array, boolean]] + 'set_arc4_uint(uint64)void': [value: bigint | number] + 'set_arc4_string(string)void': [value: string] + 'set_arc4_byte(byte)void': [value: number] + 'set_arc4_bool(bool)void': [value: boolean] + 'set_arc4_address(address)void': [value: string] + 'set_arc4_uint128(uint128)void': [value: bigint | number] + 'set_arc4_dynamic_bytes(byte[])void': [value: Uint8Array] + } +} + +/** + * The return type for each method + */ +export type GlobalStateContractReturns = { + 'get_implicit_key_arc4_uint()uint64': bigint + 'get_implicit_key_arc4_string()string': string + 'get_implicit_key_arc4_byte()byte': number + 'get_implicit_key_arc4_bool()bool': boolean + 'get_implicit_key_arc4_address()address': string + 'get_implicit_key_arc4_uint128()uint128': bigint + 'get_implicit_key_arc4_dynamic_bytes()byte[]': Uint8Array + 'get_implicit_key_tuple()(uint64,byte[],bool)': [bigint, Uint8Array, boolean] + 'get_arc4_uint()uint64': bigint + 'get_arc4_string()string': string + 'get_arc4_byte()byte': number + 'get_arc4_bool()bool': boolean + 'get_arc4_address()address': string + 'get_arc4_uint128()uint128': bigint + 'get_arc4_dynamic_bytes()byte[]': Uint8Array + 'set_implicit_key_arc4_uint(uint64)void': void + 'set_implicit_key_arc4_string(string)void': void + 'set_implicit_key_arc4_byte(byte)void': void + 'set_implicit_key_arc4_bool(bool)void': void + 'set_implicit_key_arc4_address(address)void': void + 'set_implicit_key_arc4_uint128(uint128)void': void + 'set_implicit_key_arc4_dynamic_bytes(byte[])void': void + 'set_implicit_key_tuple((uint64,byte[],bool))void': void + 'set_arc4_uint(uint64)void': void + 'set_arc4_string(string)void': void + 'set_arc4_byte(byte)void': void + 'set_arc4_bool(bool)void': void + 'set_arc4_address(address)void': void + 'set_arc4_uint128(uint128)void': void + 'set_arc4_dynamic_bytes(byte[])void': void +} + +/** + * Defines the types of available calls and state of the GlobalStateContract smart contract. + */ +export type GlobalStateContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'get_implicit_key_arc4_uint()uint64' | 'get_implicit_key_arc4_uint', { + argsObj: GlobalStateContractArgs['obj']['get_implicit_key_arc4_uint()uint64'] + argsTuple: GlobalStateContractArgs['tuple']['get_implicit_key_arc4_uint()uint64'] + returns: GlobalStateContractReturns['get_implicit_key_arc4_uint()uint64'] + }> + & Record<'get_implicit_key_arc4_string()string' | 'get_implicit_key_arc4_string', { + argsObj: GlobalStateContractArgs['obj']['get_implicit_key_arc4_string()string'] + argsTuple: GlobalStateContractArgs['tuple']['get_implicit_key_arc4_string()string'] + returns: GlobalStateContractReturns['get_implicit_key_arc4_string()string'] + }> + & Record<'get_implicit_key_arc4_byte()byte' | 'get_implicit_key_arc4_byte', { + argsObj: GlobalStateContractArgs['obj']['get_implicit_key_arc4_byte()byte'] + argsTuple: GlobalStateContractArgs['tuple']['get_implicit_key_arc4_byte()byte'] + returns: GlobalStateContractReturns['get_implicit_key_arc4_byte()byte'] + }> + & Record<'get_implicit_key_arc4_bool()bool' | 'get_implicit_key_arc4_bool', { + argsObj: GlobalStateContractArgs['obj']['get_implicit_key_arc4_bool()bool'] + argsTuple: GlobalStateContractArgs['tuple']['get_implicit_key_arc4_bool()bool'] + returns: GlobalStateContractReturns['get_implicit_key_arc4_bool()bool'] + }> + & Record<'get_implicit_key_arc4_address()address' | 'get_implicit_key_arc4_address', { + argsObj: GlobalStateContractArgs['obj']['get_implicit_key_arc4_address()address'] + argsTuple: GlobalStateContractArgs['tuple']['get_implicit_key_arc4_address()address'] + returns: GlobalStateContractReturns['get_implicit_key_arc4_address()address'] + }> + & Record<'get_implicit_key_arc4_uint128()uint128' | 'get_implicit_key_arc4_uint128', { + argsObj: GlobalStateContractArgs['obj']['get_implicit_key_arc4_uint128()uint128'] + argsTuple: GlobalStateContractArgs['tuple']['get_implicit_key_arc4_uint128()uint128'] + returns: GlobalStateContractReturns['get_implicit_key_arc4_uint128()uint128'] + }> + & Record<'get_implicit_key_arc4_dynamic_bytes()byte[]' | 'get_implicit_key_arc4_dynamic_bytes', { + argsObj: GlobalStateContractArgs['obj']['get_implicit_key_arc4_dynamic_bytes()byte[]'] + argsTuple: GlobalStateContractArgs['tuple']['get_implicit_key_arc4_dynamic_bytes()byte[]'] + returns: GlobalStateContractReturns['get_implicit_key_arc4_dynamic_bytes()byte[]'] + }> + & Record<'get_implicit_key_tuple()(uint64,byte[],bool)' | 'get_implicit_key_tuple', { + argsObj: GlobalStateContractArgs['obj']['get_implicit_key_tuple()(uint64,byte[],bool)'] + argsTuple: GlobalStateContractArgs['tuple']['get_implicit_key_tuple()(uint64,byte[],bool)'] + returns: GlobalStateContractReturns['get_implicit_key_tuple()(uint64,byte[],bool)'] + }> + & Record<'get_arc4_uint()uint64' | 'get_arc4_uint', { + argsObj: GlobalStateContractArgs['obj']['get_arc4_uint()uint64'] + argsTuple: GlobalStateContractArgs['tuple']['get_arc4_uint()uint64'] + returns: GlobalStateContractReturns['get_arc4_uint()uint64'] + }> + & Record<'get_arc4_string()string' | 'get_arc4_string', { + argsObj: GlobalStateContractArgs['obj']['get_arc4_string()string'] + argsTuple: GlobalStateContractArgs['tuple']['get_arc4_string()string'] + returns: GlobalStateContractReturns['get_arc4_string()string'] + }> + & Record<'get_arc4_byte()byte' | 'get_arc4_byte', { + argsObj: GlobalStateContractArgs['obj']['get_arc4_byte()byte'] + argsTuple: GlobalStateContractArgs['tuple']['get_arc4_byte()byte'] + returns: GlobalStateContractReturns['get_arc4_byte()byte'] + }> + & Record<'get_arc4_bool()bool' | 'get_arc4_bool', { + argsObj: GlobalStateContractArgs['obj']['get_arc4_bool()bool'] + argsTuple: GlobalStateContractArgs['tuple']['get_arc4_bool()bool'] + returns: GlobalStateContractReturns['get_arc4_bool()bool'] + }> + & Record<'get_arc4_address()address' | 'get_arc4_address', { + argsObj: GlobalStateContractArgs['obj']['get_arc4_address()address'] + argsTuple: GlobalStateContractArgs['tuple']['get_arc4_address()address'] + returns: GlobalStateContractReturns['get_arc4_address()address'] + }> + & Record<'get_arc4_uint128()uint128' | 'get_arc4_uint128', { + argsObj: GlobalStateContractArgs['obj']['get_arc4_uint128()uint128'] + argsTuple: GlobalStateContractArgs['tuple']['get_arc4_uint128()uint128'] + returns: GlobalStateContractReturns['get_arc4_uint128()uint128'] + }> + & Record<'get_arc4_dynamic_bytes()byte[]' | 'get_arc4_dynamic_bytes', { + argsObj: GlobalStateContractArgs['obj']['get_arc4_dynamic_bytes()byte[]'] + argsTuple: GlobalStateContractArgs['tuple']['get_arc4_dynamic_bytes()byte[]'] + returns: GlobalStateContractReturns['get_arc4_dynamic_bytes()byte[]'] + }> + & Record<'set_implicit_key_arc4_uint(uint64)void' | 'set_implicit_key_arc4_uint', { + argsObj: GlobalStateContractArgs['obj']['set_implicit_key_arc4_uint(uint64)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_implicit_key_arc4_uint(uint64)void'] + returns: GlobalStateContractReturns['set_implicit_key_arc4_uint(uint64)void'] + }> + & Record<'set_implicit_key_arc4_string(string)void' | 'set_implicit_key_arc4_string', { + argsObj: GlobalStateContractArgs['obj']['set_implicit_key_arc4_string(string)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_implicit_key_arc4_string(string)void'] + returns: GlobalStateContractReturns['set_implicit_key_arc4_string(string)void'] + }> + & Record<'set_implicit_key_arc4_byte(byte)void' | 'set_implicit_key_arc4_byte', { + argsObj: GlobalStateContractArgs['obj']['set_implicit_key_arc4_byte(byte)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_implicit_key_arc4_byte(byte)void'] + returns: GlobalStateContractReturns['set_implicit_key_arc4_byte(byte)void'] + }> + & Record<'set_implicit_key_arc4_bool(bool)void' | 'set_implicit_key_arc4_bool', { + argsObj: GlobalStateContractArgs['obj']['set_implicit_key_arc4_bool(bool)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_implicit_key_arc4_bool(bool)void'] + returns: GlobalStateContractReturns['set_implicit_key_arc4_bool(bool)void'] + }> + & Record<'set_implicit_key_arc4_address(address)void' | 'set_implicit_key_arc4_address', { + argsObj: GlobalStateContractArgs['obj']['set_implicit_key_arc4_address(address)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_implicit_key_arc4_address(address)void'] + returns: GlobalStateContractReturns['set_implicit_key_arc4_address(address)void'] + }> + & Record<'set_implicit_key_arc4_uint128(uint128)void' | 'set_implicit_key_arc4_uint128', { + argsObj: GlobalStateContractArgs['obj']['set_implicit_key_arc4_uint128(uint128)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_implicit_key_arc4_uint128(uint128)void'] + returns: GlobalStateContractReturns['set_implicit_key_arc4_uint128(uint128)void'] + }> + & Record<'set_implicit_key_arc4_dynamic_bytes(byte[])void' | 'set_implicit_key_arc4_dynamic_bytes', { + argsObj: GlobalStateContractArgs['obj']['set_implicit_key_arc4_dynamic_bytes(byte[])void'] + argsTuple: GlobalStateContractArgs['tuple']['set_implicit_key_arc4_dynamic_bytes(byte[])void'] + returns: GlobalStateContractReturns['set_implicit_key_arc4_dynamic_bytes(byte[])void'] + }> + & Record<'set_implicit_key_tuple((uint64,byte[],bool))void' | 'set_implicit_key_tuple', { + argsObj: GlobalStateContractArgs['obj']['set_implicit_key_tuple((uint64,byte[],bool))void'] + argsTuple: GlobalStateContractArgs['tuple']['set_implicit_key_tuple((uint64,byte[],bool))void'] + returns: GlobalStateContractReturns['set_implicit_key_tuple((uint64,byte[],bool))void'] + }> + & Record<'set_arc4_uint(uint64)void' | 'set_arc4_uint', { + argsObj: GlobalStateContractArgs['obj']['set_arc4_uint(uint64)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_arc4_uint(uint64)void'] + returns: GlobalStateContractReturns['set_arc4_uint(uint64)void'] + }> + & Record<'set_arc4_string(string)void' | 'set_arc4_string', { + argsObj: GlobalStateContractArgs['obj']['set_arc4_string(string)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_arc4_string(string)void'] + returns: GlobalStateContractReturns['set_arc4_string(string)void'] + }> + & Record<'set_arc4_byte(byte)void' | 'set_arc4_byte', { + argsObj: GlobalStateContractArgs['obj']['set_arc4_byte(byte)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_arc4_byte(byte)void'] + returns: GlobalStateContractReturns['set_arc4_byte(byte)void'] + }> + & Record<'set_arc4_bool(bool)void' | 'set_arc4_bool', { + argsObj: GlobalStateContractArgs['obj']['set_arc4_bool(bool)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_arc4_bool(bool)void'] + returns: GlobalStateContractReturns['set_arc4_bool(bool)void'] + }> + & Record<'set_arc4_address(address)void' | 'set_arc4_address', { + argsObj: GlobalStateContractArgs['obj']['set_arc4_address(address)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_arc4_address(address)void'] + returns: GlobalStateContractReturns['set_arc4_address(address)void'] + }> + & Record<'set_arc4_uint128(uint128)void' | 'set_arc4_uint128', { + argsObj: GlobalStateContractArgs['obj']['set_arc4_uint128(uint128)void'] + argsTuple: GlobalStateContractArgs['tuple']['set_arc4_uint128(uint128)void'] + returns: GlobalStateContractReturns['set_arc4_uint128(uint128)void'] + }> + & Record<'set_arc4_dynamic_bytes(byte[])void' | 'set_arc4_dynamic_bytes', { + argsObj: GlobalStateContractArgs['obj']['set_arc4_dynamic_bytes(byte[])void'] + argsTuple: GlobalStateContractArgs['tuple']['set_arc4_dynamic_bytes(byte[])void'] + returns: GlobalStateContractReturns['set_arc4_dynamic_bytes(byte[])void'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + global: { + keys: { + implicitKeyArc4Uint: bigint + implicitKeyArc4String: string + implicitKeyArc4Byte: number + implicitKeyArc4Bool: boolean + implicitKeyArc4Address: string + implicitKeyArc4Uint128: bigint + implicitKeyArc4DynamicBytes: Uint8Array + implicitKeyTuple: [bigint, Uint8Array, boolean] + arc4Uint: bigint + arc4String: string + arc4Byte: number + arc4Bool: boolean + arc4Address: string + arc4Uint128: bigint + arc4DynamicBytes: Uint8Array + } + maps: {} + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type GlobalStateContractSignatures = keyof GlobalStateContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type GlobalStateContractNonVoidMethodSignatures = keyof GlobalStateContractTypes['methods'] extends infer T ? T extends keyof GlobalStateContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the GlobalStateContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = GlobalStateContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the GlobalStateContract smart contract to the method's return type + */ +export type MethodReturn = GlobalStateContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed global state of the application. + */ +export type GlobalKeysState = GlobalStateContractTypes['state']['global']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type GlobalStateContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type GlobalStateContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: GlobalStateContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the GlobalStateContract smart contract + */ +export abstract class GlobalStateContractParamsFactory { + /** + * Constructs a no op call for the get_implicit_key_arc4_uint()uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Uint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_uint()uint64' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_string()string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4String(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_string()string' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_byte()byte ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Byte(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_byte()byte' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_bool()bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Bool(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_bool()bool' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_address()address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Address(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_address()address' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_uint128()uint128 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Uint128(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_uint128()uint128' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_dynamic_bytes()byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4DynamicBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_dynamic_bytes()byte[]' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_implicit_key_tuple()(uint64,byte[],bool) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyTuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_tuple()(uint64,byte[],bool)' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_arc4_uint()uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Uint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_uint()uint64' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_arc4_string()string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4String(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_string()string' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_arc4_byte()byte ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Byte(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_byte()byte' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_arc4_bool()bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Bool(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_bool()bool' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_arc4_address()address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Address(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_address()address' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_arc4_uint128()uint128 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Uint128(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_uint128()uint128' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get_arc4_dynamic_bytes()byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4DynamicBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_dynamic_bytes()byte[]' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the set_implicit_key_arc4_uint(uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setImplicitKeyArc4Uint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_implicit_key_arc4_uint(uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_implicit_key_arc4_string(string)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setImplicitKeyArc4String(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_implicit_key_arc4_string(string)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_implicit_key_arc4_byte(byte)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setImplicitKeyArc4Byte(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_implicit_key_arc4_byte(byte)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_implicit_key_arc4_bool(bool)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setImplicitKeyArc4Bool(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_implicit_key_arc4_bool(bool)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_implicit_key_arc4_address(address)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setImplicitKeyArc4Address(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_implicit_key_arc4_address(address)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_implicit_key_arc4_uint128(uint128)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setImplicitKeyArc4Uint128(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_implicit_key_arc4_uint128(uint128)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_implicit_key_arc4_dynamic_bytes(byte[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setImplicitKeyArc4DynamicBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_implicit_key_arc4_dynamic_bytes(byte[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_implicit_key_tuple((uint64,byte[],bool))void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setImplicitKeyTuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_implicit_key_tuple((uint64,byte[],bool))void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_arc4_uint(uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setArc4Uint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_arc4_uint(uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_arc4_string(string)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setArc4String(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_arc4_string(string)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_arc4_byte(byte)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setArc4Byte(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_arc4_byte(byte)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_arc4_bool(bool)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setArc4Bool(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_arc4_bool(bool)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_arc4_address(address)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setArc4Address(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_arc4_address(address)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_arc4_uint128(uint128)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setArc4Uint128(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_arc4_uint128(uint128)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } + /** + * Constructs a no op call for the set_arc4_dynamic_bytes(byte[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static setArc4DynamicBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'set_arc4_dynamic_bytes(byte[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value], + } + } +} + +/** + * A factory to create and deploy one or more instance of the GlobalStateContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class GlobalStateContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `GlobalStateContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new GlobalStateContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new GlobalStateContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the GlobalStateContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: GlobalStateContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new GlobalStateContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the GlobalStateContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the GlobalStateContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the GlobalStateContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new GlobalStateContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the GlobalStateContract smart contract + */ +export class GlobalStateContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `GlobalStateContractClient` + * + * @param appClient An `AppClient` instance which has been created with the GlobalStateContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `GlobalStateContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `GlobalStateContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new GlobalStateContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `GlobalStateContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new GlobalStateContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the GlobalStateContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_uint()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Uint(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_string()string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getImplicitKeyArc4String(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_byte()byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Byte(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_bool()bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Bool(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_address()address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Address(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_uint128()uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Uint128(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_dynamic_bytes()byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getImplicitKeyArc4DynamicBytes(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_tuple()(uint64,byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getImplicitKeyTuple(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_uint()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getArc4Uint(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_string()string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getArc4String(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_byte()byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getArc4Byte(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_bool()bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getArc4Bool(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_address()address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getArc4Address(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_uint128()uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getArc4Uint128(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_dynamic_bytes()byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.getArc4DynamicBytes(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_uint(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setImplicitKeyArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Uint(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_string(string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setImplicitKeyArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setImplicitKeyArc4String(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_byte(byte)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setImplicitKeyArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Byte(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_bool(bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setImplicitKeyArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Bool(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_address(address)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setImplicitKeyArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Address(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_uint128(uint128)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setImplicitKeyArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Uint128(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_dynamic_bytes(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setImplicitKeyArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setImplicitKeyArc4DynamicBytes(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_tuple((uint64,byte[],bool))void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setImplicitKeyTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setImplicitKeyTuple(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_uint(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setArc4Uint(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_string(string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setArc4String(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_byte(byte)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setArc4Byte(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_bool(bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setArc4Bool(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_address(address)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setArc4Address(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_uint128(uint128)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setArc4Uint128(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_dynamic_bytes(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + setArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateContractParamsFactory.setArc4DynamicBytes(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the GlobalStateContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_uint()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Uint(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_string()string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getImplicitKeyArc4String(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_byte()byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Byte(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_bool()bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Bool(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_address()address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Address(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_uint128()uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Uint128(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_dynamic_bytes()byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getImplicitKeyArc4DynamicBytes(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_tuple()(uint64,byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getImplicitKeyTuple(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_uint()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getArc4Uint(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_string()string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getArc4String(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_byte()byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getArc4Byte(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_bool()bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getArc4Bool(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_address()address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getArc4Address(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_uint128()uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getArc4Uint128(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_dynamic_bytes()byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.getArc4DynamicBytes(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_uint(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setImplicitKeyArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Uint(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_string(string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setImplicitKeyArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setImplicitKeyArc4String(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_byte(byte)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setImplicitKeyArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Byte(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_bool(bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setImplicitKeyArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Bool(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_address(address)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setImplicitKeyArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Address(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_uint128(uint128)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setImplicitKeyArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Uint128(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_dynamic_bytes(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setImplicitKeyArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setImplicitKeyArc4DynamicBytes(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_tuple((uint64,byte[],bool))void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setImplicitKeyTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setImplicitKeyTuple(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_uint(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setArc4Uint(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_string(string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setArc4String(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_byte(byte)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setArc4Byte(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_bool(bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setArc4Bool(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_address(address)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setArc4Address(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_uint128(uint128)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setArc4Uint128(params)) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_dynamic_bytes(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + setArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateContractParamsFactory.setArc4DynamicBytes(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the GlobalStateContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_uint()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Uint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Uint(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_implicit_key_arc4_uint()uint64'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_string()string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4String: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getImplicitKeyArc4String(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_implicit_key_arc4_string()string'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_byte()byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Byte: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Byte(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_implicit_key_arc4_byte()byte'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_bool()bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Bool: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Bool(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_implicit_key_arc4_bool()bool'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_address()address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Address: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Address(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_implicit_key_arc4_address()address'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_uint128()uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Uint128: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getImplicitKeyArc4Uint128(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_implicit_key_arc4_uint128()uint128'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_arc4_dynamic_bytes()byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4DynamicBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getImplicitKeyArc4DynamicBytes(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_implicit_key_arc4_dynamic_bytes()byte[]'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_implicit_key_tuple()(uint64,byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyTuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getImplicitKeyTuple(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_implicit_key_tuple()(uint64,byte[],bool)'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_uint()uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Uint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getArc4Uint(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_arc4_uint()uint64'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_string()string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4String: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getArc4String(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_arc4_string()string'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_byte()byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Byte: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getArc4Byte(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_arc4_byte()byte'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_bool()bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Bool: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getArc4Bool(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_arc4_bool()bool'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_address()address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Address: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getArc4Address(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_arc4_address()address'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_uint128()uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Uint128: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getArc4Uint128(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_arc4_uint128()uint128'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `get_arc4_dynamic_bytes()byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4DynamicBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.getArc4DynamicBytes(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['get_arc4_dynamic_bytes()byte[]'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_uint(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setImplicitKeyArc4Uint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Uint(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_implicit_key_arc4_uint(uint64)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_string(string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setImplicitKeyArc4String: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setImplicitKeyArc4String(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_implicit_key_arc4_string(string)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_byte(byte)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setImplicitKeyArc4Byte: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Byte(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_implicit_key_arc4_byte(byte)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_bool(bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setImplicitKeyArc4Bool: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Bool(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_implicit_key_arc4_bool(bool)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_address(address)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setImplicitKeyArc4Address: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Address(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_implicit_key_arc4_address(address)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_uint128(uint128)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setImplicitKeyArc4Uint128: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setImplicitKeyArc4Uint128(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_implicit_key_arc4_uint128(uint128)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_arc4_dynamic_bytes(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setImplicitKeyArc4DynamicBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setImplicitKeyArc4DynamicBytes(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_implicit_key_arc4_dynamic_bytes(byte[])void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_implicit_key_tuple((uint64,byte[],bool))void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setImplicitKeyTuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setImplicitKeyTuple(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_implicit_key_tuple((uint64,byte[],bool))void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_uint(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setArc4Uint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setArc4Uint(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_arc4_uint(uint64)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_string(string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setArc4String: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setArc4String(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_arc4_string(string)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_byte(byte)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setArc4Byte: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setArc4Byte(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_arc4_byte(byte)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_bool(bool)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setArc4Bool: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setArc4Bool(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_arc4_bool(bool)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_address(address)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setArc4Address: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setArc4Address(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_arc4_address(address)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_uint128(uint128)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setArc4Uint128: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setArc4Uint128(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_arc4_uint128(uint128)void'])} + }, + + /** + * Makes a call to the GlobalStateContract smart contract using the `set_arc4_dynamic_bytes(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + setArc4DynamicBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateContractParamsFactory.setArc4DynamicBytes(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateContractReturns['set_arc4_dynamic_bytes(byte[])void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new GlobalStateContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current GlobalStateContract app + */ + state = { + /** + * Methods to access global state for the current GlobalStateContract app + */ + global: { + /** + * Get all current keyed values from global state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.global.getAll() + return { + implicitKeyArc4Uint: result.implicit_key_arc4_uint, + implicitKeyArc4String: result.implicit_key_arc4_string, + implicitKeyArc4Byte: result.implicit_key_arc4_byte, + implicitKeyArc4Bool: result.implicit_key_arc4_bool, + implicitKeyArc4Address: result.implicit_key_arc4_address, + implicitKeyArc4Uint128: result.implicit_key_arc4_uint128, + implicitKeyArc4DynamicBytes: result.implicit_key_arc4_dynamic_bytes, + implicitKeyTuple: result.implicit_key_tuple, + arc4Uint: result.arc4_uint, + arc4String: result.arc4_string, + arc4Byte: result.arc4_byte, + arc4Bool: result.arc4_bool, + arc4Address: result.arc4_address, + arc4Uint128: result.arc4_uint128, + arc4DynamicBytes: result.arc4_dynamic_bytes, + } + }, + /** + * Get the current value of the implicit_key_arc4_uint key in global state + */ + implicitKeyArc4Uint: async (): Promise => { return (await this.appClient.state.global.getValue("implicit_key_arc4_uint")) as bigint | undefined }, + /** + * Get the current value of the implicit_key_arc4_string key in global state + */ + implicitKeyArc4String: async (): Promise => { return (await this.appClient.state.global.getValue("implicit_key_arc4_string")) as string | undefined }, + /** + * Get the current value of the implicit_key_arc4_byte key in global state + */ + implicitKeyArc4Byte: async (): Promise => { return (await this.appClient.state.global.getValue("implicit_key_arc4_byte")) as number | undefined }, + /** + * Get the current value of the implicit_key_arc4_bool key in global state + */ + implicitKeyArc4Bool: async (): Promise => { return (await this.appClient.state.global.getValue("implicit_key_arc4_bool")) as boolean | undefined }, + /** + * Get the current value of the implicit_key_arc4_address key in global state + */ + implicitKeyArc4Address: async (): Promise => { return (await this.appClient.state.global.getValue("implicit_key_arc4_address")) as string | undefined }, + /** + * Get the current value of the implicit_key_arc4_uint128 key in global state + */ + implicitKeyArc4Uint128: async (): Promise => { return (await this.appClient.state.global.getValue("implicit_key_arc4_uint128")) as bigint | undefined }, + /** + * Get the current value of the implicit_key_arc4_dynamic_bytes key in global state + */ + implicitKeyArc4DynamicBytes: async (): Promise => { return (await this.appClient.state.global.getValue("implicit_key_arc4_dynamic_bytes")) as Uint8Array | undefined }, + /** + * Get the current value of the implicit_key_tuple key in global state + */ + implicitKeyTuple: async (): Promise<[bigint, Uint8Array, boolean] | undefined> => { return (await this.appClient.state.global.getValue("implicit_key_tuple")) as [bigint, Uint8Array, boolean] | undefined }, + /** + * Get the current value of the arc4_uint key in global state + */ + arc4Uint: async (): Promise => { return (await this.appClient.state.global.getValue("arc4_uint")) as bigint | undefined }, + /** + * Get the current value of the arc4_string key in global state + */ + arc4String: async (): Promise => { return (await this.appClient.state.global.getValue("arc4_string")) as string | undefined }, + /** + * Get the current value of the arc4_byte key in global state + */ + arc4Byte: async (): Promise => { return (await this.appClient.state.global.getValue("arc4_byte")) as number | undefined }, + /** + * Get the current value of the arc4_bool key in global state + */ + arc4Bool: async (): Promise => { return (await this.appClient.state.global.getValue("arc4_bool")) as boolean | undefined }, + /** + * Get the current value of the arc4_address key in global state + */ + arc4Address: async (): Promise => { return (await this.appClient.state.global.getValue("arc4_address")) as string | undefined }, + /** + * Get the current value of the arc4_uint128 key in global state + */ + arc4Uint128: async (): Promise => { return (await this.appClient.state.global.getValue("arc4_uint128")) as bigint | undefined }, + /** + * Get the current value of the arc4_dynamic_bytes key in global state + */ + arc4DynamicBytes: async (): Promise => { return (await this.appClient.state.global.getValue("arc4_dynamic_bytes")) as Uint8Array | undefined }, + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): GlobalStateContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a get_implicit_key_arc4_uint()uint64 method call against the GlobalStateContract contract + */ + getImplicitKeyArc4Uint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Uint(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_string()string method call against the GlobalStateContract contract + */ + getImplicitKeyArc4String(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4String(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_byte()byte method call against the GlobalStateContract contract + */ + getImplicitKeyArc4Byte(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Byte(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_bool()bool method call against the GlobalStateContract contract + */ + getImplicitKeyArc4Bool(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Bool(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_address()address method call against the GlobalStateContract contract + */ + getImplicitKeyArc4Address(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Address(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_uint128()uint128 method call against the GlobalStateContract contract + */ + getImplicitKeyArc4Uint128(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Uint128(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_dynamic_bytes()byte[] method call against the GlobalStateContract contract + */ + getImplicitKeyArc4DynamicBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4DynamicBytes(params))) + return this + }, + /** + * Add a get_implicit_key_tuple()(uint64,byte[],bool) method call against the GlobalStateContract contract + */ + getImplicitKeyTuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyTuple(params))) + return this + }, + /** + * Add a get_arc4_uint()uint64 method call against the GlobalStateContract contract + */ + getArc4Uint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Uint(params))) + return this + }, + /** + * Add a get_arc4_string()string method call against the GlobalStateContract contract + */ + getArc4String(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4String(params))) + return this + }, + /** + * Add a get_arc4_byte()byte method call against the GlobalStateContract contract + */ + getArc4Byte(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Byte(params))) + return this + }, + /** + * Add a get_arc4_bool()bool method call against the GlobalStateContract contract + */ + getArc4Bool(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Bool(params))) + return this + }, + /** + * Add a get_arc4_address()address method call against the GlobalStateContract contract + */ + getArc4Address(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Address(params))) + return this + }, + /** + * Add a get_arc4_uint128()uint128 method call against the GlobalStateContract contract + */ + getArc4Uint128(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Uint128(params))) + return this + }, + /** + * Add a get_arc4_dynamic_bytes()byte[] method call against the GlobalStateContract contract + */ + getArc4DynamicBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4DynamicBytes(params))) + return this + }, + /** + * Add a set_implicit_key_arc4_uint(uint64)void method call against the GlobalStateContract contract + */ + setImplicitKeyArc4Uint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setImplicitKeyArc4Uint(params))) + return this + }, + /** + * Add a set_implicit_key_arc4_string(string)void method call against the GlobalStateContract contract + */ + setImplicitKeyArc4String(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setImplicitKeyArc4String(params))) + return this + }, + /** + * Add a set_implicit_key_arc4_byte(byte)void method call against the GlobalStateContract contract + */ + setImplicitKeyArc4Byte(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setImplicitKeyArc4Byte(params))) + return this + }, + /** + * Add a set_implicit_key_arc4_bool(bool)void method call against the GlobalStateContract contract + */ + setImplicitKeyArc4Bool(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setImplicitKeyArc4Bool(params))) + return this + }, + /** + * Add a set_implicit_key_arc4_address(address)void method call against the GlobalStateContract contract + */ + setImplicitKeyArc4Address(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setImplicitKeyArc4Address(params))) + return this + }, + /** + * Add a set_implicit_key_arc4_uint128(uint128)void method call against the GlobalStateContract contract + */ + setImplicitKeyArc4Uint128(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setImplicitKeyArc4Uint128(params))) + return this + }, + /** + * Add a set_implicit_key_arc4_dynamic_bytes(byte[])void method call against the GlobalStateContract contract + */ + setImplicitKeyArc4DynamicBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setImplicitKeyArc4DynamicBytes(params))) + return this + }, + /** + * Add a set_implicit_key_tuple((uint64,byte[],bool))void method call against the GlobalStateContract contract + */ + setImplicitKeyTuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setImplicitKeyTuple(params))) + return this + }, + /** + * Add a set_arc4_uint(uint64)void method call against the GlobalStateContract contract + */ + setArc4Uint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setArc4Uint(params))) + return this + }, + /** + * Add a set_arc4_string(string)void method call against the GlobalStateContract contract + */ + setArc4String(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setArc4String(params))) + return this + }, + /** + * Add a set_arc4_byte(byte)void method call against the GlobalStateContract contract + */ + setArc4Byte(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setArc4Byte(params))) + return this + }, + /** + * Add a set_arc4_bool(bool)void method call against the GlobalStateContract contract + */ + setArc4Bool(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setArc4Bool(params))) + return this + }, + /** + * Add a set_arc4_address(address)void method call against the GlobalStateContract contract + */ + setArc4Address(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setArc4Address(params))) + return this + }, + /** + * Add a set_arc4_uint128(uint128)void method call against the GlobalStateContract contract + */ + setArc4Uint128(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setArc4Uint128(params))) + return this + }, + /** + * Add a set_arc4_dynamic_bytes(byte[])void method call against the GlobalStateContract contract + */ + setArc4DynamicBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.setArc4DynamicBytes(params))) + return this + }, + /** + * Add a clear state call to the GlobalStateContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as GlobalStateContractComposer + } +} +export type GlobalStateContractComposer = { + /** + * Calls the get_implicit_key_arc4_uint()uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Uint(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_implicit_key_arc4_uint()uint64'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_string()string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4String(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_implicit_key_arc4_string()string'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_byte()byte ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Byte(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_implicit_key_arc4_byte()byte'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_bool()bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Bool(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_implicit_key_arc4_bool()bool'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_address()address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Address(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_implicit_key_arc4_address()address'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_uint128()uint128 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Uint128(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_implicit_key_arc4_uint128()uint128'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_dynamic_bytes()byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4DynamicBytes(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_implicit_key_arc4_dynamic_bytes()byte[]'] | undefined]> + + /** + * Calls the get_implicit_key_tuple()(uint64,byte[],bool) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyTuple(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_implicit_key_tuple()(uint64,byte[],bool)'] | undefined]> + + /** + * Calls the get_arc4_uint()uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Uint(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_arc4_uint()uint64'] | undefined]> + + /** + * Calls the get_arc4_string()string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4String(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_arc4_string()string'] | undefined]> + + /** + * Calls the get_arc4_byte()byte ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Byte(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_arc4_byte()byte'] | undefined]> + + /** + * Calls the get_arc4_bool()bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Bool(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_arc4_bool()bool'] | undefined]> + + /** + * Calls the get_arc4_address()address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Address(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_arc4_address()address'] | undefined]> + + /** + * Calls the get_arc4_uint128()uint128 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Uint128(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_arc4_uint128()uint128'] | undefined]> + + /** + * Calls the get_arc4_dynamic_bytes()byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4DynamicBytes(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['get_arc4_dynamic_bytes()byte[]'] | undefined]> + + /** + * Calls the set_implicit_key_arc4_uint(uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setImplicitKeyArc4Uint(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_implicit_key_arc4_uint(uint64)void'] | undefined]> + + /** + * Calls the set_implicit_key_arc4_string(string)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setImplicitKeyArc4String(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_implicit_key_arc4_string(string)void'] | undefined]> + + /** + * Calls the set_implicit_key_arc4_byte(byte)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setImplicitKeyArc4Byte(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_implicit_key_arc4_byte(byte)void'] | undefined]> + + /** + * Calls the set_implicit_key_arc4_bool(bool)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setImplicitKeyArc4Bool(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_implicit_key_arc4_bool(bool)void'] | undefined]> + + /** + * Calls the set_implicit_key_arc4_address(address)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setImplicitKeyArc4Address(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_implicit_key_arc4_address(address)void'] | undefined]> + + /** + * Calls the set_implicit_key_arc4_uint128(uint128)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setImplicitKeyArc4Uint128(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_implicit_key_arc4_uint128(uint128)void'] | undefined]> + + /** + * Calls the set_implicit_key_arc4_dynamic_bytes(byte[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setImplicitKeyArc4DynamicBytes(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_implicit_key_arc4_dynamic_bytes(byte[])void'] | undefined]> + + /** + * Calls the set_implicit_key_tuple((uint64,byte[],bool))void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setImplicitKeyTuple(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_implicit_key_tuple((uint64,byte[],bool))void'] | undefined]> + + /** + * Calls the set_arc4_uint(uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setArc4Uint(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_arc4_uint(uint64)void'] | undefined]> + + /** + * Calls the set_arc4_string(string)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setArc4String(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_arc4_string(string)void'] | undefined]> + + /** + * Calls the set_arc4_byte(byte)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setArc4Byte(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_arc4_byte(byte)void'] | undefined]> + + /** + * Calls the set_arc4_bool(bool)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setArc4Bool(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_arc4_bool(bool)void'] | undefined]> + + /** + * Calls the set_arc4_address(address)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setArc4Address(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_arc4_address(address)void'] | undefined]> + + /** + * Calls the set_arc4_uint128(uint128)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setArc4Uint128(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_arc4_uint128(uint128)void'] | undefined]> + + /** + * Calls the set_arc4_dynamic_bytes(byte[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + setArc4DynamicBytes(params?: CallParams): GlobalStateContractComposer<[...TReturns, GlobalStateContractReturns['set_arc4_dynamic_bytes(byte[])void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the GlobalStateContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): GlobalStateContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): GlobalStateContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type GlobalStateContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/GlobalStateValidator.ts b/examples/p-py/projects/p-py-frontend/src/contracts/GlobalStateValidator.ts new file mode 100644 index 0000000..483c414 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/GlobalStateValidator.ts @@ -0,0 +1,557 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"GlobalStateValidator","structs":{},"methods":[{"name":"validate_g_args","args":[{"type":"uint64","name":"arg1"},{"type":"string","name":"arg2"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[72],"errorMessage":"transaction type is appl"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyYBBMDrXGcxG0EAEyg2GgCOAQABADEZFDEYEERCAAgxGRQxGBQQQzYaATYaAjYaACgSRDYaAUsCEkQ2GgISRDEWSTgQgQYSRIEBwhpLARJEMRaBAcIaSwESRDEWORoBSwESRDYaARJEgQFD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the GlobalStateValidator contract + */ +export type GlobalStateValidatorArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'validate_g_args(uint64,string)void': { + arg1: bigint | number + arg2: string + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'validate_g_args(uint64,string)void': [arg1: bigint | number, arg2: string] + } +} + +/** + * The return type for each method + */ +export type GlobalStateValidatorReturns = { + 'validate_g_args(uint64,string)void': void +} + +/** + * Defines the types of available calls and state of the GlobalStateValidator smart contract. + */ +export type GlobalStateValidatorTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'validate_g_args(uint64,string)void' | 'validate_g_args', { + argsObj: GlobalStateValidatorArgs['obj']['validate_g_args(uint64,string)void'] + argsTuple: GlobalStateValidatorArgs['tuple']['validate_g_args(uint64,string)void'] + returns: GlobalStateValidatorReturns['validate_g_args(uint64,string)void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type GlobalStateValidatorSignatures = keyof GlobalStateValidatorTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the GlobalStateValidator smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = GlobalStateValidatorTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the GlobalStateValidator smart contract to the method's return type + */ +export type MethodReturn = GlobalStateValidatorTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type GlobalStateValidatorCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type GlobalStateValidatorDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: GlobalStateValidatorCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the GlobalStateValidator smart contract + */ +export abstract class GlobalStateValidatorParamsFactory { + /** + * Constructs a no op call for the validate_g_args(uint64,string)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static validateGArgs(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'validate_g_args(uint64,string)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arg1, params.args.arg2], + } + } +} + +/** + * A factory to create and deploy one or more instance of the GlobalStateValidator smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class GlobalStateValidatorFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `GlobalStateValidatorFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new GlobalStateValidatorClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new GlobalStateValidatorClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the GlobalStateValidator smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: GlobalStateValidatorDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new GlobalStateValidatorClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the GlobalStateValidator smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the GlobalStateValidator smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the GlobalStateValidator smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new GlobalStateValidatorClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the GlobalStateValidator smart contract + */ +export class GlobalStateValidatorClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `GlobalStateValidatorClient` + * + * @param appClient An `AppClient` instance which has been created with the GlobalStateValidator app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `GlobalStateValidatorClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `GlobalStateValidatorClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new GlobalStateValidatorClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `GlobalStateValidatorClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new GlobalStateValidatorClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the GlobalStateValidator smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the GlobalStateValidator smart contract using the `validate_g_args(uint64,string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + validateGArgs: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(GlobalStateValidatorParamsFactory.validateGArgs(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the GlobalStateValidator smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the GlobalStateValidator smart contract using the `validate_g_args(uint64,string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + validateGArgs: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(GlobalStateValidatorParamsFactory.validateGArgs(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the GlobalStateValidator smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the GlobalStateValidator smart contract using the `validate_g_args(uint64,string)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + validateGArgs: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(GlobalStateValidatorParamsFactory.validateGArgs(params)) + return {...result, return: result.return as unknown as (undefined | GlobalStateValidatorReturns['validate_g_args(uint64,string)void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new GlobalStateValidatorClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current GlobalStateValidator app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): GlobalStateValidatorComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a validate_g_args(uint64,string)void method call against the GlobalStateValidator contract + */ + validateGArgs(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.validateGArgs(params))) + return this + }, + /** + * Add a clear state call to the GlobalStateValidator contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as GlobalStateValidatorComposer + } +} +export type GlobalStateValidatorComposer = { + /** + * Calls the validate_g_args(uint64,string)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + validateGArgs(params?: CallParams): GlobalStateValidatorComposer<[...TReturns, GlobalStateValidatorReturns['validate_g_args(uint64,string)void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the GlobalStateValidator smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): GlobalStateValidatorComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): GlobalStateValidatorComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type GlobalStateValidatorComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/HelloWorld.ts b/examples/p-py/projects/p-py-frontend/src/contracts/HelloWorld.ts index 1fc6caf..e60b7c5 100644 --- a/examples/p-py/projects/p-py-frontend/src/contracts/HelloWorld.ts +++ b/examples/p-py/projects/p-py-frontend/src/contracts/HelloWorld.ts @@ -2,29 +2,19 @@ /** * This file was automatically generated by @algorandfoundation/algokit-client-generator. * DO NOT MODIFY IT BY HAND. - * requires: @algorandfoundation/algokit-utils: ^7 + * requires: @algorandfoundation/algokit-utils: ^10 */ import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' -import { ABIReturn, AppReturn, SendAppTransactionResult } from '@algorandfoundation/algokit-utils/types/app' -import { Arc56Contract, getArc56ReturnValue, getABIStructFromABITuple } from '@algorandfoundation/algokit-utils/types/app-arc56' -import { - AppClient as _AppClient, - AppClientMethodCallParams, - AppClientParams, - AppClientBareCallParams, - CallOnComplete, - AppClientCompilationParams, - ResolveAppClientByCreatorAndName, - ResolveAppClientByNetwork, - CloneAppClientParams, -} from '@algorandfoundation/algokit-utils/types/app-client' -import { AppFactory as _AppFactory, AppFactoryAppClientParams, AppFactoryResolveAppClientByCreatorAndNameParams, AppFactoryDeployParams, AppFactoryParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' -import { TransactionComposer, AppCallMethodCall, AppMethodCallTransactionArgument, SimulateOptions, RawSimulateOptions, SkipSignaturesSimulateOptions } from '@algorandfoundation/algokit-utils/types/composer' -import { SendParams, SendSingleTransactionResult, SendAtomicTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' -import { Address, encodeAddress, modelsv2, OnApplicationComplete, Transaction, TransactionSigner } from 'algosdk' -import SimulateResponse = modelsv2.SimulateResponse - -export const APP_SPEC: Arc56Contract = {"name":"HelloWorld","structs":{},"methods":[{"name":"hello","args":[{"type":"string","name":"name"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[37],"errorMessage":"OnCompletion must be NoOp && can only call when creating"},{"pc":[26],"errorMessage":"OnCompletion must be NoOp && can only call when not creating"},{"pc":[47],"errorMessage":"invalid array length header"},{"pc":[55],"errorMessage":"invalid number of bytes for arc4.dynamic_array"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"},"byteCode":{"approval":"CzEbQQAYgAQCvs4RNhoAjgEAAQAxGRQxGBBEQgALMRkUMRgUEESBAUM2GgFJgQBZgQIISwEVEkRXAgCAB0hlbGxvLCBMUEkVFlcGAkxQgAQVH3x1TFCwgQFD","clear":"C4EBQw=="},"compilerInfo":{"compiler":"puya","compilerVersion":{"major":5,"minor":4,"patch":0}},"events":[],"templateVariables":{}} as unknown as Arc56Contract +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"HelloWorld","structs":{},"methods":[{"name":"hello","args":[{"type":"string","name":"name"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[44],"errorMessage":"invalid array length header"},{"pc":[52],"errorMessage":"invalid number of bytes for arc4.dynamic_array"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHNtYXJ0X2NvbnRyYWN0cy9oZWxsb193b3JsZC9jb250cmFjdC5weTo1CiAgICAvLyBjbGFzcyBIZWxsb1dvcmxkKEFSQzRDb250cmFjdCk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9fX2FsZ29weV9kZWZhdWx0X2NyZWF0ZUA1CiAgICBwdXNoYnl0ZXMgMHgwMmJlY2UxMSAvLyBtZXRob2QgImhlbGxvKHN0cmluZylzdHJpbmciCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCBtYWluX2hlbGxvX3JvdXRlQDMKICAgIGVycgoKbWFpbl9oZWxsb19yb3V0ZUAzOgogICAgLy8gc21hcnRfY29udHJhY3RzL2hlbGxvX3dvcmxkL2NvbnRyYWN0LnB5OjYKICAgIC8vIEBhYmltZXRob2QoKQogICAgdHhuIE9uQ29tcGxldGlvbgogICAgIQogICAgdHhuIEFwcGxpY2F0aW9uSUQKICAgICYmCiAgICBhc3NlcnQKICAgIGIgaGVsbG8KCm1haW5fX19hbGdvcHlfZGVmYXVsdF9jcmVhdGVANToKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICAhCiAgICAmJgogICAgcmV0dXJuCgoKLy8gc21hcnRfY29udHJhY3RzLmhlbGxvX3dvcmxkLmNvbnRyYWN0LkhlbGxvV29ybGQuaGVsbG9bcm91dGluZ10oKSAtPiB2b2lkOgpoZWxsbzoKICAgIC8vIHNtYXJ0X2NvbnRyYWN0cy9oZWxsb193b3JsZC9jb250cmFjdC5weTo2CiAgICAvLyBAYWJpbWV0aG9kKCkKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDEKICAgIGR1cAogICAgcHVzaGludCAwCiAgICBleHRyYWN0X3VpbnQxNiAvLyBvbiBlcnJvcjogaW52YWxpZCBhcnJheSBsZW5ndGggaGVhZGVyCiAgICBwdXNoaW50IDIKICAgICsKICAgIGRpZyAxCiAgICBsZW4KICAgID09CiAgICBhc3NlcnQgLy8gaW52YWxpZCBudW1iZXIgb2YgYnl0ZXMgZm9yIGFyYzQuZHluYW1pY19hcnJheTxhcmM0LnVpbnQ4PgogICAgZXh0cmFjdCAyIDAKICAgIC8vIHNtYXJ0X2NvbnRyYWN0cy9oZWxsb193b3JsZC9jb250cmFjdC5weTo4CiAgICAvLyByZXR1cm4gIkhlbGxvLCAiICsgbmFtZQogICAgcHVzaGJ5dGVzICJIZWxsbywgIgogICAgc3dhcAogICAgY29uY2F0CiAgICAvLyBzbWFydF9jb250cmFjdHMvaGVsbG9fd29ybGQvY29udHJhY3QucHk6NgogICAgLy8gQGFiaW1ldGhvZCgpCiAgICBkdXAKICAgIGxlbgogICAgaXRvYgogICAgZXh0cmFjdCA2IDIKICAgIHN3YXAKICAgIGNvbmNhdAogICAgcHVzaGJ5dGVzIDB4MTUxZjdjNzUKICAgIHN3YXAKICAgIGNvbmNhdAogICAgbG9nCiAgICBwdXNoaW50IDEKICAgIHJldHVybgo=","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CzEbQQAYgAQCvs4RNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEM2GgFJgQBZgQIISwEVEkRXAgCAB0hlbGxvLCBMUEkVFlcGAkxQgAQVH3x1TFCwgQFD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract /** * A state record containing binary data @@ -137,7 +127,7 @@ export type MethodReturn = HelloWorldTy * Defines supported create method params for this smart contract */ export type HelloWorldCreateCallParams = - | Expand + | Expand /** * Defines arguments required for the deploy method. */ @@ -258,7 +248,7 @@ export class HelloWorldFactory { * @param params The params for the bare (raw) call * @returns The params for a create call */ - bare: (params?: Expand) => { + bare: (params?: Expand) => { return this.appFactory.params.bare.create(params) }, }, @@ -279,7 +269,7 @@ export class HelloWorldFactory { * @param params The params for the bare (raw) call * @returns The transaction for a create call */ - bare: (params?: Expand) => { + bare: (params?: Expand) => { return this.appFactory.createTransaction.bare.create(params) }, }, @@ -300,7 +290,7 @@ export class HelloWorldFactory { * @param params The params for the bare (raw) call * @returns The create result */ - bare: async (params?: Expand) => { + bare: async (params?: Expand) => { const result = await this.appFactory.send.bare.create(params) return { result: result.result, appClient: new HelloWorldClient(result.appClient) } }, @@ -336,15 +326,7 @@ export class HelloWorldClient { appSpec: APP_SPEC, }) } - - /** - * Checks for decode errors on the given return value and maps the return value to the return type for the given method - * @returns The typed return value or undefined if there was no value - */ - decodeReturnValue(method: TSignature, returnValue: ABIReturn | undefined) { - return returnValue !== undefined ? getArc56ReturnValue>(returnValue, this.appClient.getABIMethod(method), APP_SPEC.structs) : undefined - } - + /** * Returns a new `HelloWorldClient` client, resolving the app by creator address and name * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). @@ -412,7 +394,7 @@ export class HelloWorldClient { * @param params The params for the smart contract call * @returns The call params */ - hello: (params: CallParams & {onComplete?: OnApplicationComplete.NoOpOC}) => { + hello: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { return this.appClient.params.call(HelloWorldParamsFactory.hello(params)) }, @@ -438,7 +420,7 @@ export class HelloWorldClient { * @param params The params for the smart contract call * @returns The call transaction */ - hello: (params: CallParams & {onComplete?: OnApplicationComplete.NoOpOC}) => { + hello: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { return this.appClient.createTransaction.call(HelloWorldParamsFactory.hello(params)) }, @@ -464,7 +446,7 @@ export class HelloWorldClient { * @param params The params for the smart contract call * @returns The call result */ - hello: async (params: CallParams & SendParams & {onComplete?: OnApplicationComplete.NoOpOC}) => { + hello: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { const result = await this.appClient.send.call(HelloWorldParamsFactory.hello(params)) return {...result, return: result.return as unknown as (undefined | HelloWorldReturns['hello(string)string'])} }, @@ -474,7 +456,7 @@ export class HelloWorldClient { /** * Clone this app client with different params * - * @param params The params to use for the the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. * @returns A new app client with the altered params */ public clone(params: CloneAppClientParams) { @@ -487,18 +469,16 @@ export class HelloWorldClient { state = { } - public newGroup(): HelloWorldComposer { + public newGroup(composerConfig?: TransactionComposerConfig): HelloWorldComposer { const client = this - const composer = this.algorand.newGroup() + const composer = this.algorand.newGroup(composerConfig) let promiseChain:Promise = Promise.resolve() - const resultMappers: Array any)> = [] return { /** * Add a hello(string)string method call against the HelloWorld contract */ - hello(params: CallParams & {onComplete?: OnApplicationComplete.NoOpOC}) { + hello(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.hello(params))) - resultMappers.push((v) => client.decodeReturnValue('hello(string)string', v)) return this }, /** @@ -521,7 +501,7 @@ export class HelloWorldClient { const result = await (!options ? composer.simulate() : composer.simulate(options)) return { ...result, - returns: result.returns?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i]!(val) : val.returnValue) + returns: result.returns?.map(val => val.returnValue) } }, async send(params?: SendParams) { @@ -529,7 +509,7 @@ export class HelloWorldClient { const result = await composer.send(params) return { ...result, - returns: result.returns?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i]!(val) : val.returnValue) + returns: result.returns?.map(val => val.returnValue) } } } as unknown as HelloWorldComposer @@ -539,7 +519,6 @@ export type HelloWorldComposer = { /** * Calls the hello(string)string ABI method. * - * @param args The arguments for the contract call * @param params Any additional parameters for the call * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions */ @@ -548,7 +527,7 @@ export type HelloWorldComposer = { /** * Makes a clear_state call to an existing instance of the HelloWorld smart contract. * - * @param args The arguments for the bare call + * @param params Any additional parameters for the bare call * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions */ clearState(params?: AppClientBareCallParams): HelloWorldComposer<[...TReturns, undefined]> @@ -575,7 +554,7 @@ export type HelloWorldComposer = { */ send(params?: SendParams): Promise> } -export type HelloWorldComposerResults = Expand = Expand diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/ITxnOpsContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/ITxnOpsContract.ts new file mode 100644 index 0000000..a3d8854 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/ITxnOpsContract.ts @@ -0,0 +1,554 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"ITxnOpsContract","structs":{},"methods":[{"name":"verify_itxn_ops","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyADAQboByYBAwaBATEbQQAYgAROfNnLNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEOxI7IQgQWyGSiyHiiyQCiyHzIAsgG2IrIQMgmyBySyCLO0BzIJEkS0CCQSRLQQIhJEtwAQIxJEtwEQIhJEIkM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the ITxnOpsContract contract + */ +export type ITxnOpsContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_itxn_ops()void': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_itxn_ops()void': [] + } +} + +/** + * The return type for each method + */ +export type ITxnOpsContractReturns = { + 'verify_itxn_ops()void': void +} + +/** + * Defines the types of available calls and state of the ITxnOpsContract smart contract. + */ +export type ITxnOpsContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_itxn_ops()void' | 'verify_itxn_ops', { + argsObj: ITxnOpsContractArgs['obj']['verify_itxn_ops()void'] + argsTuple: ITxnOpsContractArgs['tuple']['verify_itxn_ops()void'] + returns: ITxnOpsContractReturns['verify_itxn_ops()void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type ITxnOpsContractSignatures = keyof ITxnOpsContractTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the ITxnOpsContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = ITxnOpsContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the ITxnOpsContract smart contract to the method's return type + */ +export type MethodReturn = ITxnOpsContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type ITxnOpsContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type ITxnOpsContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: ITxnOpsContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the ITxnOpsContract smart contract + */ +export abstract class ITxnOpsContractParamsFactory { + /** + * Constructs a no op call for the verify_itxn_ops()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyItxnOps(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_itxn_ops()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the ITxnOpsContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class ITxnOpsContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `ITxnOpsContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new ITxnOpsContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new ITxnOpsContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the ITxnOpsContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: ITxnOpsContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new ITxnOpsContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ITxnOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ITxnOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ITxnOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new ITxnOpsContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the ITxnOpsContract smart contract + */ +export class ITxnOpsContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `ITxnOpsContractClient` + * + * @param appClient An `AppClient` instance which has been created with the ITxnOpsContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `ITxnOpsContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `ITxnOpsContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new ITxnOpsContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `ITxnOpsContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new ITxnOpsContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the ITxnOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the ITxnOpsContract smart contract using the `verify_itxn_ops()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyItxnOps: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ITxnOpsContractParamsFactory.verifyItxnOps(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the ITxnOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the ITxnOpsContract smart contract using the `verify_itxn_ops()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyItxnOps: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ITxnOpsContractParamsFactory.verifyItxnOps(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the ITxnOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the ITxnOpsContract smart contract using the `verify_itxn_ops()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyItxnOps: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ITxnOpsContractParamsFactory.verifyItxnOps(params)) + return {...result, return: result.return as unknown as (undefined | ITxnOpsContractReturns['verify_itxn_ops()void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new ITxnOpsContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current ITxnOpsContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): ITxnOpsContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_itxn_ops()void method call against the ITxnOpsContract contract + */ + verifyItxnOps(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyItxnOps(params))) + return this + }, + /** + * Add a clear state call to the ITxnOpsContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as ITxnOpsContractComposer + } +} +export type ITxnOpsContractComposer = { + /** + * Calls the verify_itxn_ops()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyItxnOps(params?: CallParams): ITxnOpsContractComposer<[...TReturns, ITxnOpsContractReturns['verify_itxn_ops()void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the ITxnOpsContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): ITxnOpsContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): ITxnOpsContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type ITxnOpsContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/ImmutableArrayContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/ImmutableArrayContract.ts new file mode 100644 index 0000000..ff91ca4 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/ImmutableArrayContract.ts @@ -0,0 +1,2231 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"ImmutableArrayContract","structs":{},"methods":[{"name":"test_uint64_array","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_biguint_array","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_bool_array","args":[{"type":"uint64","name":"length"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_fixed_size_tuple_array","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_fixed_size_named_tuple_array","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_dynamic_sized_tuple_array","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_dynamic_sized_named_tuple_array","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_implicit_conversion_log","args":[{"type":"uint64[]","name":"arr"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_implicit_conversion_emit","args":[{"type":"uint64[]","name":"arr"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[{"name":"emit_test","args":[{"type":"uint64[]","name":"field1"}]}],"recommendations":{}},{"name":"test_nested_array","args":[{"type":"uint64","name":"arr_to_add"},{"type":"uint64[][]","name":"arr"}],"returns":{"type":"uint64[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_bit_packed_tuples","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"sum_uints_and_lengths_and_trues","args":[{"type":"uint64[]","name":"arr1"},{"type":"bool[]","name":"arr2"},{"type":"(uint64,bool,bool)[]","name":"arr3"},{"type":"(uint64,string)[]","name":"arr4"}],"returns":{"type":"(uint64,uint64,uint64,uint64)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_uint64_return","args":[{"type":"uint64","name":"append"}],"returns":{"type":"uint64[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_bool_return","args":[{"type":"uint64","name":"append"}],"returns":{"type":"bool[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_tuple_return","args":[{"type":"uint64","name":"append"}],"returns":{"type":"(uint64,bool,bool)[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_dynamic_tuple_return","args":[{"type":"uint64","name":"append"}],"returns":{"type":"(uint64,string)[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_convert_to_array_and_back","args":[{"type":"(uint64,bool,bool)[]","name":"arr"},{"type":"uint64","name":"append"}],"returns":{"type":"(uint64,bool,bool)[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_concat_with_arc4_tuple","args":[{"type":"(uint64,uint64)","name":"arg"}],"returns":{"type":"uint64[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_concat_with_native_tuple","args":[{"type":"(uint64,uint64)","name":"arg"}],"returns":{"type":"uint64[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_dynamic_concat_with_arc4_tuple","args":[{"type":"(string,string)","name":"arg"}],"returns":{"type":"string[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_dynamic_concat_with_native_tuple","args":[{"type":"(string,string)","name":"arg"}],"returns":{"type":"string[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_concat_immutable_dynamic","args":[{"type":"(uint64,string)[]","name":"imm1"},{"type":"(uint64,string)[]","name":"imm2"}],"returns":{"type":"(uint64,string)[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_immutable_arc4","args":[{"type":"(uint64,uint64)[]","name":"imm"}],"returns":{"type":"(uint64,uint64)[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_imm_fixed_arr","args":[],"returns":{"type":"(uint64,uint64)[3]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":11},"local":{"ints":0,"bytes":0}},"keys":{"global":{"a":{"keyType":"AVMString","valueType":"uint64[]","key":"YQ=="},"g":{"keyType":"AVMString","valueType":"bool[]","key":"Zw=="},"c":{"keyType":"AVMString","valueType":"(uint64,uint64)[]","key":"Yw=="},"d":{"keyType":"AVMString","valueType":"(uint64,bool,bool)[]","key":"ZA=="},"e":{"keyType":"AVMString","valueType":"(uint64,byte[])[]","key":"ZQ=="},"f":{"keyType":"AVMString","valueType":"(uint64,string)[]","key":"Zg=="},"bool2":{"keyType":"AVMString","valueType":"(bool,bool)[]","key":"Ym9vbDI="},"bool7":{"keyType":"AVMString","valueType":"(uint64,bool,bool,bool,bool,bool,bool,bool,uint64)[]","key":"Ym9vbDc="},"bool8":{"keyType":"AVMString","valueType":"(uint64,bool,bool,bool,bool,bool,bool,bool,bool,uint64)[]","key":"Ym9vbDg="},"bool9":{"keyType":"AVMString","valueType":"(uint64,bool,bool,bool,bool,bool,bool,bool,bool,bool,uint64)[]","key":"Ym9vbDk="},"imm_fixed_arr":{"keyType":"AVMString","valueType":"(uint64,uint64)[3]","key":"aW1tX2ZpeGVkX2Fycg=="}},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[4104],"errorMessage":"check self.imm_fixed_arr exists"},{"pc":[2179,2487],"errorMessage":"expected 1, 0"},{"pc":[2094,2402],"errorMessage":"expected 1st element to be correct"},{"pc":[2099,2409],"errorMessage":"expected 2nd element to be correct"},{"pc":[2240,2549],"errorMessage":"expected 4, 3"},{"pc":[3988],"errorMessage":"expected arrays to be different"},{"pc":[4022],"errorMessage":"expected arrays to be the same"},{"pc":[1548],"errorMessage":"expected element 0 to be False"},{"pc":[1567],"errorMessage":"expected element 1 to be False"},{"pc":[1585],"errorMessage":"expected element 2 to be True"},{"pc":[4049],"errorMessage":"expected items on iteration to be the same"},{"pc":[1611],"errorMessage":"expected last element to be False"},{"pc":[3935],"errorMessage":"expected non empty array"},{"pc":[3363],"errorMessage":"expected string length to match index"},{"pc":[4099],"errorMessage":"expected sum to be 10"},{"pc":[4072],"errorMessage":"expected sum to be 15"},{"pc":[852,1156,1221,1289,1346,1456,1541,1560,1579,1602,1753,1817,2050,2131,2196,2358,2441,2504,3214,3307,3950,4007,4045,4091],"errorMessage":"index access is out of bounds"},{"pc":[968,1009,1065,1092,1132,1160,1204,1269,1326,1438,1525,1656,1715,1779,1906,2008,2114,2316,2424,2681,2722,3012,3021,3030,3039,3107,3144,3188,3269,3910,3933],"errorMessage":"invalid array length header"},{"pc":[923,996,1120,1194,1244,1314,1426,1692,1881,2622,2769,2833,2919,2958,2989,3438,3571,3745,3779,3814],"errorMessage":"max array length exceeded"},{"pc":[1307],"errorMessage":"overflow"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock 0x 0x151f7c75 0x0000 0x00 0x0002 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0x000a 0x62696775696e74 0x000200000000000000010000000000000002 0x000200040007000161000162 "imm_fixed_arr"
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@31
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x44d42f99 0xb7eaa60b 0x743d70ed 0x1c7e0494 0xa2d5860b 0xe05fc564 0x1e092b83 0x01310262 0xc8654a98 0x89d196f8 0x6cb7c991 0x9898bf02 0xf6b61ee8 0x60b86a7b 0x73ad283f 0x529dfae9 0x206d514f 0xe06465e2 0xec0300a2 0xecdf14af 0x511aca64 0x29852e4f 0x6d4aa358 0xb7cb96bd // method "test_uint64_array()void", method "test_biguint_array()void", method "test_bool_array(uint64)void", method "test_fixed_size_tuple_array()void", method "test_fixed_size_named_tuple_array()void", method "test_dynamic_sized_tuple_array()void", method "test_dynamic_sized_named_tuple_array()void", method "test_implicit_conversion_log(uint64[])void", method "test_implicit_conversion_emit(uint64[])void", method "test_nested_array(uint64,uint64[][])uint64[]", method "test_bit_packed_tuples()void", method "sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)", method "test_uint64_return(uint64)uint64[]", method "test_bool_return(uint64)bool[]", method "test_tuple_return(uint64)(uint64,bool,bool)[]", method "test_dynamic_tuple_return(uint64)(uint64,string)[]", method "test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]", method "test_concat_with_arc4_tuple((uint64,uint64))uint64[]", method "test_concat_with_native_tuple((uint64,uint64))uint64[]", method "test_dynamic_concat_with_arc4_tuple((string,string))string[]", method "test_dynamic_concat_with_native_tuple((string,string))string[]", method "test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]", method "test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]", method "test_imm_fixed_arr()(uint64,uint64)[3]"
    txna ApplicationArgs 0
    match test_uint64_array test_biguint_array test_bool_array test_fixed_size_tuple_array test_fixed_size_named_tuple_array test_dynamic_sized_tuple_array test_dynamic_sized_named_tuple_array test_implicit_conversion_log test_implicit_conversion_emit test_nested_array test_bit_packed_tuples sum_uints_and_lengths_and_trues test_uint64_return test_bool_return test_tuple_return test_dynamic_tuple_return test_convert_to_array_and_back test_concat_with_arc4_tuple test_concat_with_native_tuple test_dynamic_concat_with_arc4_tuple test_dynamic_concat_with_native_tuple test_concat_immutable_dynamic test_immutable_arc4 test_imm_fixed_arr
    err

main___algopy_default_create@31:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// _puya_lib.arc4.dynamic_array_pop_fixed_size(array: bytes, fixed_byte_size: uint64) -> bytes, bytes:
dynamic_array_pop_fixed_size:
    proto 2 2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    itob
    extract 6 0
    frame_dig -2
    swap
    replace2 0
    dup
    len
    frame_dig -1
    -
    dup2
    frame_dig -1
    extract3
    uncover 2
    intc_0 // 0
    uncover 3
    substring3
    retsub


// _puya_lib.arc4.dynamic_array_pop_dynamic_element(array: bytes) -> bytes, bytes:
dynamic_array_pop_dynamic_element:
    proto 1 2
    frame_dig -1
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    dup
    intc_2 // 2
    *
    dup
    frame_dig -1
    extract 2 0
    dup
    cover 2
    dup
    uncover 2
    extract_uint16
    dup
    uncover 2
    dup
    len
    swap
    cover 2
    substring3
    bytec_0 // 0x
    intc_0 // 0

dynamic_array_pop_dynamic_element_for_header@1:
    frame_dig 6
    frame_dig 1
    <
    bz dynamic_array_pop_dynamic_element_after_for@4
    frame_dig 2
    frame_dig 6
    dup
    cover 2
    extract_uint16
    intc_2 // 2
    -
    itob
    extract 6 2
    frame_dig 5
    swap
    concat
    frame_bury 5
    intc_2 // 2
    +
    frame_bury 6
    b dynamic_array_pop_dynamic_element_for_header@1

dynamic_array_pop_dynamic_element_after_for@4:
    frame_dig 0
    itob
    extract 6 2
    frame_dig 5
    concat
    frame_dig 1
    intc_2 // 2
    +
    frame_dig 2
    swap
    frame_dig 3
    substring3
    concat
    frame_dig 4
    frame_bury 0
    frame_bury 1
    retsub


// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
dynamic_array_concat_bits:
    proto 4 1
    bytec_0 // ""
    dupn 2
    frame_dig -4
    intc_0 // 0
    extract_uint16
    dupn 2
    frame_dig -2
    +
    dup
    itob
    extract 6 0
    frame_dig -4
    swap
    replace2 0
    cover 2
    swap
    pushint 7
    +
    intc_3 // 8
    /
    dup
    uncover 2
    pushint 7
    +
    intc_3 // 8
    /
    dup
    cover 2
    <
    bz dynamic_array_concat_bits_after_if_else@2
    frame_dig 6
    frame_dig 5
    -
    bzero
    frame_dig 4
    swap
    concat
    frame_bury 4

dynamic_array_concat_bits_after_if_else@2:
    intc_0 // 0
    frame_bury 0
    frame_dig 3
    pushint 16
    +
    dup
    frame_bury 2
    frame_dig -2
    +
    frame_bury 1

dynamic_array_concat_bits_while_top@3:
    frame_dig 2
    frame_dig 1
    <
    bz dynamic_array_concat_bits_after_while@5
    frame_dig -3
    frame_dig 0
    dup
    cover 2
    getbit
    frame_dig 4
    frame_dig 2
    dup
    cover 3
    uncover 2
    setbit
    frame_bury 4
    intc_1 // 1
    +
    frame_bury 2
    frame_dig -1
    +
    frame_bury 0
    b dynamic_array_concat_bits_while_top@3

dynamic_array_concat_bits_after_while@5:
    frame_dig 4
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_byte_length_head(array: bytes, new_items_bytes: bytes, new_items_count: uint64) -> bytes:
dynamic_array_concat_byte_length_head:
    proto 3 1
    frame_dig -3
    intc_0 // 0
    extract_uint16
    dup
    frame_dig -1
    +
    swap
    intc_2 // 2
    *
    intc_2 // 2
    +
    dig 1
    itob
    extract 6 2
    cover 2
    frame_dig -3
    intc_2 // 2
    dig 2
    substring3
    frame_dig -1
    intc_2 // 2
    *
    bzero
    concat
    frame_dig -3
    len
    frame_dig -3
    uncover 3
    uncover 2
    substring3
    concat
    frame_dig -2
    concat
    swap
    intc_2 // 2
    *
    dup
    intc_0 // 0

dynamic_array_concat_byte_length_head_for_header@2:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_byte_length_head_after_for@4
    frame_dig 3
    dup
    itob
    extract 6 2
    frame_dig 1
    frame_dig 4
    dup
    cover 4
    uncover 2
    replace3
    dup
    frame_bury 1
    dig 1
    extract_uint16
    intc_2 // 2
    +
    +
    frame_bury 3
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_byte_length_head_for_header@2

dynamic_array_concat_byte_length_head_after_for@4:
    frame_dig 0
    frame_dig 1
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    bytec_0 // ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.sum_imm_fixed(arr: bytes) -> uint64:
sum_imm_fixed:
    // tests/artifacts/Arrays/immutable.py:570-571
    // @subroutine
    // def sum_imm_fixed(arr: NativeStruct3) -> UInt64:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:572
    // total = UInt64(0)
    intc_0 // 0
    dup

sum_imm_fixed_for_header@1:
    // tests/artifacts/Arrays/immutable.py:573
    // for item in arr:
    frame_dig 1
    pushint 3
    <
    bz sum_imm_fixed_after_for@4
    // tests/artifacts/Arrays/immutable.py:573-574
    // for item in arr:
    //     total += item.foo
    frame_dig 1
    dup
    pushint 16
    *
    frame_dig -1
    swap
    pushint 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:574
    // total += item.foo
    dup
    // tests/artifacts/Arrays/immutable.py:573-574
    // for item in arr:
    //     total += item.foo
    intc_0 // 0
    // tests/artifacts/Arrays/immutable.py:574
    // total += item.foo
    extract_uint64
    frame_dig 0
    +
    // tests/artifacts/Arrays/immutable.py:575
    // total += item.bar
    swap
    intc_3 // 8
    extract_uint64
    +
    frame_bury 0
    intc_1 // 1
    +
    frame_bury 1
    b sum_imm_fixed_for_header@1

sum_imm_fixed_after_for@4:
    // tests/artifacts/Arrays/immutable.py:576
    // return total
    retsub


// tests.artifacts.Arrays.immutable.times(n: uint64) -> bytes:
times:
    // tests/artifacts/Arrays/immutable.py:579-580
    // @subroutine
    // def times(n: UInt64) -> String:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:581
    // result = String()
    bytec_0 // ""
    // tests/artifacts/Arrays/immutable.py:582
    // for _i in urange(n):
    intc_0 // 0

times_for_header@1:
    // tests/artifacts/Arrays/immutable.py:582
    // for _i in urange(n):
    frame_dig 1
    frame_dig -1
    <
    bz times_after_for@4
    // tests/artifacts/Arrays/immutable.py:583
    // result += String(" ")
    frame_dig 0
    pushbytes " "
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:582
    // for _i in urange(n):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b times_for_header@1

times_after_for@4:
    // tests/artifacts/Arrays/immutable.py:584
    // return result
    retsub


// tests.artifacts.Arrays.immutable.add_x(arr: bytes, x: uint64) -> bytes:
add_x:
    // tests/artifacts/Arrays/immutable.py:587-588
    // @subroutine
    // def add_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:589
    // for i in urange(x):
    intc_0 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/immutable.py:589
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/immutable.py:590
    // arr = arr.append(i)
    frame_dig 0
    dup
    itob
    frame_dig -2
    swap
    concat // on error: max array length exceeded
    frame_dig -2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury -2
    // tests/artifacts/Arrays/immutable.py:589
    // for i in urange(x):
    intc_1 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    // tests/artifacts/Arrays/immutable.py:591
    // return arr
    frame_dig -2
    swap
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_array[routing]() -> void:
test_uint64_array:
    // tests/artifacts/Arrays/immutable.py:99
    // arr = arr.append(UInt64(42))
    pushbytes 0x0001000000000000002a
    // tests/artifacts/Arrays/immutable.py:103
    // arr = add_x(arr, UInt64(5))
    pushint 5
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:104
    // assert arr.length == 6
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 6
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:105
    // assert arr[-1] == 4
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:107
    // arr = arr.append(UInt64(43))
    pushint 43
    itob
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    dupn 2
    // tests/artifacts/Arrays/immutable.py:108
    // assert arr.length == 7
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 7
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:109
    // assert arr[-1] == 43
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 43
    ==
    assert
    intc_2 // 2
    // tests/artifacts/Arrays/immutable.py:110
    // assert arr[0] == 42
    extract_uint64
    pushint 42
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:596
    // for _i in urange(x):
    intc_0 // 0

test_uint64_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:596
    // for _i in urange(x):
    dup
    // tests/artifacts/Arrays/immutable.py:112
    // arr = pop_x(arr, UInt64(3))
    pushint 3
    // tests/artifacts/Arrays/immutable.py:596
    // for _i in urange(x):
    <
    bz test_uint64_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:597
    // arr = arr.pop()
    dig 1
    intc_3 // 8
    callsub dynamic_array_pop_fixed_size
    bury 3
    pop
    // tests/artifacts/Arrays/immutable.py:596
    // for _i in urange(x):
    dup
    intc_1 // 1
    +
    bury 1
    b test_uint64_array_for_header@2

test_uint64_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:113
    // assert arr.length == 4
    dig 1
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:114
    // assert arr[-1] == 2
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    intc_2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:116
    // arr = add_x(arr, UInt64(10))
    pushint 10
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:117
    // assert arr.length == 14
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 14
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:118
    // assert arr[-1] == 9
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 9
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:120
    // arr = arr.append(UInt64(44))
    pushint 44
    itob
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:121
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:122
    // assert arr[-1] == 44
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 44
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:124
    // arr = arr.replace(2, UInt64(23))
    pushint 23
    itob
    replace2 18 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:125
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    pushint 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:126
    // assert arr[2] == 23
    dup
    pushint 18
    extract_uint64
    pushint 23
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:128
    // self.a = arr
    pushbytes "a"
    swap
    app_global_put
    // tests/artifacts/Arrays/immutable.py:94
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_biguint_array[routing]() -> void:
test_biguint_array:
    // tests/artifacts/Arrays/immutable.py:135
    // arr = arr.append(BigUInt(Txn.num_app_args - 1))
    txn NumAppArgs
    intc_1 // 1
    -
    itob
    pushint 64
    bzero
    dup
    cover 2
    b|
    // tests/artifacts/Arrays/immutable.py:132
    // arr = ImmutableArray[BigUInt]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:135
    // arr = arr.append(BigUInt(Txn.num_app_args - 1))
    swap
    concat // on error: max array length exceeded
    pushbytes 0x0001
    replace2 0
    dupn 2
    // tests/artifacts/Arrays/immutable.py:136
    // assert arr.length == 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    intc_1 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:137
    // assert arr[-1] == 0
    intc_1 // 1
    -
    swap
    extract 2 0
    swap
    pushint 64
    *
    pushint 64
    extract3 // on error: index access is out of bounds
    bytec_0 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:603
    // for i in urange(x):
    intc_0 // 0

test_biguint_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:603
    // for i in urange(x):
    dup
    // tests/artifacts/Arrays/immutable.py:139
    // arr = add_xb(arr, UInt64(5))
    pushint 5
    // tests/artifacts/Arrays/immutable.py:603
    // for i in urange(x):
    <
    bz test_biguint_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:604
    // arr = arr.append(BigUInt(i))
    dupn 2
    itob
    dig 4
    b|
    dig 3
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 3
    // tests/artifacts/Arrays/immutable.py:603
    // for i in urange(x):
    intc_1 // 1
    +
    bury 1
    b test_biguint_array_for_header@2

test_biguint_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:140
    // assert arr.length == 6
    dig 1
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 6
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:141
    // assert arr[-1] == 4
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    pushint 64
    *
    pushint 64
    extract3 // on error: index access is out of bounds
    pushbytes 0x04
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:143
    // arr = arr.append(BigUInt(2**512 - 1) - Txn.num_app_args)
    txn NumAppArgs
    itob
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    swap
    b-
    dup
    len
    pushint 64
    <=
    assert // overflow
    dig 5
    b|
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:144
    // assert arr.length == 7
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 7
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:145
    // assert arr[-1] == 2**512 - 2
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    pushint 64
    *
    pushint 64
    extract3 // on error: index access is out of bounds
    pushbytes 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:146
    // assert arr[0] == 0
    dig 1
    extract 2 64
    bytec_0 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:148
    // arr = arr.append(BigUInt(2**512 - 1))
    swap
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:149
    // assert arr.length == 8
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    intc_3 // 8
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:150
    // assert arr[-1] == 2**512 - 1
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    pushint 64
    *
    pushint 64
    extract3 // on error: index access is out of bounds
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:151
    // assert arr[0] == 0
    dup
    extract 2 64
    bytec_0 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:153
    // Box(ImmutableArray[BigUInt], key=b"biguint").value = arr
    bytec 7 // 0x62696775696e74
    box_del
    pop
    bytec 7 // 0x62696775696e74
    swap
    box_put
    // tests/artifacts/Arrays/immutable.py:130
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_array[routing]() -> void:
test_bool_array:
    bytec_0 // ""
    // tests/artifacts/Arrays/immutable.py:155
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:157
    // arr = ImmutableArray[bool]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:161
    // for i in urange(length):
    intc_0 // 0

test_bool_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:161
    // for i in urange(length):
    dup
    dig 3
    <
    bz test_bool_array_after_for@5
    // tests/artifacts/Arrays/immutable.py:162
    // arr = arr.append(i == Txn.num_app_args)
    txn NumAppArgs
    dig 1
    dup
    uncover 2
    ==
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    dig 3
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    bury 3
    // tests/artifacts/Arrays/immutable.py:161
    // for i in urange(length):
    intc_1 // 1
    +
    bury 1
    b test_bool_array_for_header@2

test_bool_array_after_for@5:
    // tests/artifacts/Arrays/immutable.py:164
    // assert arr.length == length
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    bury 5
    dig 3
    dup
    cover 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:166
    // if length > 0:
    bz test_bool_array_after_if_else@7
    // tests/artifacts/Arrays/immutable.py:167
    // assert not arr[0], "expected element 0 to be False"
    dig 3
    assert // index access is out of bounds
    dig 1
    pushint 16
    getbit
    !
    assert // expected element 0 to be False

test_bool_array_after_if_else@7:
    // tests/artifacts/Arrays/immutable.py:168
    // if length > 1:
    dig 2
    intc_1 // 1
    >
    bz test_bool_array_after_if_else@9
    // tests/artifacts/Arrays/immutable.py:169
    // assert not arr[1], "expected element 1 to be False"
    intc_1 // 1
    dig 4
    <
    assert // index access is out of bounds
    dig 1
    pushint 17
    getbit
    !
    assert // expected element 1 to be False

test_bool_array_after_if_else@9:
    // tests/artifacts/Arrays/immutable.py:170
    // if length > 2:
    dig 2
    intc_2 // 2
    >
    bz test_bool_array_after_if_else@11
    // tests/artifacts/Arrays/immutable.py:171
    // assert arr[2], "expected element 2 to be True"
    intc_2 // 2
    dig 4
    <
    assert // index access is out of bounds
    dig 1
    pushint 18
    getbit
    assert // expected element 2 to be True

test_bool_array_after_if_else@11:
    // tests/artifacts/Arrays/immutable.py:172
    // if length > 3:
    dig 2
    pushint 3
    >
    bz test_bool_array_after_if_else@13
    // tests/artifacts/Arrays/immutable.py:173
    // assert not arr[length - 1], "expected last element to be False"
    dig 2
    intc_1 // 1
    -
    dup
    dig 5
    <
    assert // index access is out of bounds
    pushint 16
    +
    dig 2
    swap
    getbit
    !
    assert // expected last element to be False

test_bool_array_after_if_else@13:
    // tests/artifacts/Arrays/immutable.py:175
    // self.g = arr
    pushbytes "g"
    dig 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:176
    // if length:
    dig 2
    bz test_bool_array_after_if_else@15
    dig 3
    intc_1 // 1
    -
    dup
    itob
    extract 6 0
    dig 3
    swap
    replace2 0
    dig 1
    pushint 16
    +
    intc_0 // 0
    setbit
    swap
    pushint 7
    +
    intc_3 // 8
    /
    intc_2 // 2
    +
    intc_0 // 0
    swap
    substring3
    // tests/artifacts/Arrays/immutable.py:178
    // assert arr.length == length - 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dig 3
    intc_1 // 1
    -
    ==
    assert

test_bool_array_after_if_else@15:
    // tests/artifacts/Arrays/immutable.py:155
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_tuple_array[routing]() -> void:
test_fixed_size_tuple_array:
    // tests/artifacts/Arrays/immutable.py:182
    // arr = ImmutableArray[tuple[UInt64, UInt64]]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:185
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_tuple_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:185
    // for i in urange(5):
    dup
    pushint 5
    <
    bz test_fixed_size_tuple_array_after_for@5
    // tests/artifacts/Arrays/immutable.py:186
    // arr = arr.append((i + 1, i + 2))
    dupn 2
    intc_1 // 1
    +
    swap
    intc_2 // 2
    +
    dig 1
    itob
    swap
    itob
    concat
    dig 3
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 3
    bury 1
    b test_fixed_size_tuple_array_for_header@2

test_fixed_size_tuple_array_after_for@5:
    // tests/artifacts/Arrays/immutable.py:188
    // assert arr.length == 5
    dig 1
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:189
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:190
    // assert arr[-1] == (UInt64(5), UInt64(6))
    swap
    intc_1 // 1
    -
    pushint 16
    *
    pushint 16
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 5
    ==
    swap
    pushint 6
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:192
    // arr = arr.pop()
    pushint 16
    callsub dynamic_array_pop_fixed_size
    bury 1
    // tests/artifacts/Arrays/immutable.py:193
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:194
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:195
    // assert arr[-1] == (UInt64(4), UInt64(5))
    swap
    intc_1 // 1
    -
    pushint 16
    *
    pushint 16
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 4
    ==
    swap
    pushint 5
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:196
    // self.c = arr
    pushbytes "c"
    swap
    app_global_put
    // tests/artifacts/Arrays/immutable.py:180
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_named_tuple_array[routing]() -> void:
test_fixed_size_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:200
    // arr = ImmutableArray[MyTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:203
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_named_tuple_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:203
    // for i in urange(5):
    dup
    pushint 5
    <
    bz test_fixed_size_named_tuple_array_after_for@5
    // tests/artifacts/Arrays/immutable.py:204
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i * 3 % 2 == 0))
    dupn 2
    intc_2 // 2
    %
    !
    dig 1
    pushint 3
    *
    intc_2 // 2
    %
    !
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    dig 3
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 3
    // tests/artifacts/Arrays/immutable.py:203
    // for i in urange(5):
    intc_1 // 1
    +
    bury 1
    b test_fixed_size_named_tuple_array_for_header@2

test_fixed_size_named_tuple_array_after_for@5:
    // tests/artifacts/Arrays/immutable.py:206
    // assert arr.length == 5
    dig 1
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    pushint 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:207
    // foo, bar, baz = arr[0]
    dup
    extract 2 9
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64
    getbit
    uncover 2
    pushint 65
    getbit
    // tests/artifacts/Arrays/immutable.py:208
    // assert foo == 0
    uncover 2
    !
    assert
    // tests/artifacts/Arrays/immutable.py:209
    // assert bar
    swap
    assert
    // tests/artifacts/Arrays/immutable.py:210
    // assert baz
    assert
    // tests/artifacts/Arrays/immutable.py:211
    // self.d = arr
    pushbytes "d"
    swap
    app_global_put
    // tests/artifacts/Arrays/immutable.py:198
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_tuple_array[routing]() -> void:
test_dynamic_sized_tuple_array:
    bytec_0 // ""
    // tests/artifacts/Arrays/immutable.py:215
    // arr = ImmutableArray[tuple[UInt64, Bytes]]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:218
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_tuple_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:218
    // for i in urange(5):
    dup
    pushint 5
    <
    bz test_dynamic_sized_tuple_array_after_for@5
    // tests/artifacts/Arrays/immutable.py:219
    // arr = arr.append((i + 1, op.bzero(i)))
    dupn 2
    intc_1 // 1
    +
    swap
    bzero
    dig 3
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    bury 3
    bury 1
    b test_dynamic_sized_tuple_array_for_header@2

test_dynamic_sized_tuple_array_after_for@5:
    // tests/artifacts/Arrays/immutable.py:221
    // assert arr.length == 5
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    bury 4
    pushint 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:222
    // for i in urange(5):
    intc_0 // 0
    bury 1

test_dynamic_sized_tuple_array_for_header@6:
    // tests/artifacts/Arrays/immutable.py:222
    // for i in urange(5):
    dup
    pushint 5
    <
    bz test_dynamic_sized_tuple_array_after_for@9
    // tests/artifacts/Arrays/immutable.py:223
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    dig 1
    extract 2 0
    dig 1
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    dig 6
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:224
    // assert arr[i][1].length == i, "expected 2nd element to be correct"
    len
    uncover 2
    ==
    assert // expected 2nd element to be correct
    bury 1
    b test_dynamic_sized_tuple_array_for_header@6

test_dynamic_sized_tuple_array_after_for@9:
    // tests/artifacts/Arrays/immutable.py:226
    // arr = arr.pop()
    dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:227
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:228
    // assert arr[0] == (UInt64(1), op.bzero(0)), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    intc_0 // 0
    bzero
    uncover 2
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:229
    // assert arr[-1] == (UInt64(4), op.bzero(3)), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4
    ==
    pushint 3
    bzero
    uncover 2
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:230
    // self.e = arr
    pushbytes "e"
    swap
    app_global_put
    // tests/artifacts/Arrays/immutable.py:213
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_named_tuple_array[routing]() -> void:
test_dynamic_sized_named_tuple_array:
    bytec_0 // ""
    // tests/artifacts/Arrays/immutable.py:234
    // arr = ImmutableArray[MyDynamicSizedTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:237
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_named_tuple_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:237
    // for i in urange(5):
    dup
    pushint 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@5
    // tests/artifacts/Arrays/immutable.py:238
    // arr = arr.append(MyDynamicSizedTuple(foo=i + 1, bar=times(i)))
    dupn 2
    intc_1 // 1
    +
    swap
    callsub times
    dig 3
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    bury 3
    bury 1
    b test_dynamic_sized_named_tuple_array_for_header@2

test_dynamic_sized_named_tuple_array_after_for@5:
    // tests/artifacts/Arrays/immutable.py:240
    // assert arr.length == 5
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    bury 4
    pushint 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:241
    // for i in urange(5):
    intc_0 // 0
    bury 1

test_dynamic_sized_named_tuple_array_for_header@6:
    // tests/artifacts/Arrays/immutable.py:241
    // for i in urange(5):
    dup
    pushint 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@9
    // tests/artifacts/Arrays/immutable.py:242
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    dig 1
    extract 2 0
    dig 1
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    dig 6
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:243
    // assert arr[i][1] == times(i), "expected 2nd element to be correct"
    uncover 2
    callsub times
    ==
    assert // expected 2nd element to be correct
    bury 1
    b test_dynamic_sized_named_tuple_array_for_header@6

test_dynamic_sized_named_tuple_array_after_for@9:
    // tests/artifacts/Arrays/immutable.py:245
    // arr = arr.pop()
    dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:246
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    pushint 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:247
    // assert arr[0] == MyDynamicSizedTuple(UInt64(1), String()), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    swap
    bytec_0 // ""
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:248
    // assert arr[-1] == MyDynamicSizedTuple(UInt64(4), String("   ")), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4
    ==
    swap
    pushbytes "   "
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:249
    // self.f = arr
    pushbytes "f"
    swap
    app_global_put
    // tests/artifacts/Arrays/immutable.py:232
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_log[routing]() -> void:
test_implicit_conversion_log:
    // tests/artifacts/Arrays/immutable.py:251
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:253
    // log(arr)
    log
    // tests/artifacts/Arrays/immutable.py:251
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_emit[routing]() -> void:
test_implicit_conversion_emit:
    // tests/artifacts/Arrays/immutable.py:257
    // arc4.emit("emit_test", arr)
    pushbytes 0xfa40c0530002
    // tests/artifacts/Arrays/immutable.py:255
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:257
    // arc4.emit("emit_test", arr)
    concat
    log
    // tests/artifacts/Arrays/immutable.py:255
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_nested_array[routing]() -> void:
test_nested_array:
    intc_0 // 0
    dupn 2
    bytec_0 // ""
    dupn 5
    // tests/artifacts/Arrays/immutable.py:259
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:263-264
    // # add n new arrays
    // for i in urange(arr_to_add):
    intc_0 // 0

test_nested_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:263-264
    // # add n new arrays
    // for i in urange(arr_to_add):
    dup
    dig 3
    <
    bz test_nested_array_after_for@9
    // tests/artifacts/Arrays/immutable.py:265
    // extra_arr = ImmutableArray[UInt64]()
    bytec_2 // 0x0000
    bury 12
    // tests/artifacts/Arrays/immutable.py:266
    // for j in urange(i):
    intc_0 // 0
    bury 5

test_nested_array_for_header@4:
    // tests/artifacts/Arrays/immutable.py:266
    // for j in urange(i):
    dig 4
    dig 1
    <
    bz test_nested_array_after_for@7
    // tests/artifacts/Arrays/immutable.py:267
    // extra_arr = extra_arr.append(j)
    dig 4
    dup
    itob
    dig 13
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 13
    // tests/artifacts/Arrays/immutable.py:266
    // for j in urange(i):
    intc_1 // 1
    +
    bury 5
    b test_nested_array_for_header@4

test_nested_array_after_for@7:
    // tests/artifacts/Arrays/immutable.py:268
    // arr = arr.append(extra_arr)
    dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    bytec 4 // 0x0002
    dig 14
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    bury 2
    // tests/artifacts/Arrays/immutable.py:263-264
    // # add n new arrays
    // for i in urange(arr_to_add):
    dup
    intc_1 // 1
    +
    bury 1
    b test_nested_array_for_header@2

test_nested_array_after_for@9:
    // tests/artifacts/Arrays/immutable.py:270-271
    // # sum inner arrays and return an array containing sums
    // totals = ImmutableArray[UInt64]()
    bytec_2 // 0x0000
    bury 10
    // tests/artifacts/Arrays/immutable.py:272
    // for inner_arr in arr:
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    bury 9
    intc_0 // 0
    bury 7

test_nested_array_for_header@10:
    // tests/artifacts/Arrays/immutable.py:272
    // for inner_arr in arr:
    dig 6
    dig 9
    <
    bz test_nested_array_after_for@13
    dig 1
    extract 2 0
    dig 7
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dup2
    extract_uint16
    intc_3 // 8
    *
    intc_2 // 2
    +
    extract3
    dup
    bury 12
    // tests/artifacts/Arrays/immutable.py:610
    // total = UInt64()
    intc_0 // 0
    bury 5
    // tests/artifacts/Arrays/immutable.py:611
    // for i in arr:
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    bury 8
    intc_0 // 0
    bury 6

test_nested_array_for_header@15:
    // tests/artifacts/Arrays/immutable.py:611
    // for i in arr:
    dig 5
    dig 8
    <
    bz test_nested_array_after_for@17
    dig 10
    extract 2 0
    dig 6
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:612
    // total += i
    dig 5
    +
    bury 5
    intc_1 // 1
    +
    bury 6
    b test_nested_array_for_header@15

test_nested_array_after_for@17:
    // tests/artifacts/Arrays/immutable.py:273
    // totals = totals.append(sum_arr(inner_arr))
    dig 3
    itob
    dig 10
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 10
    dig 6
    intc_1 // 1
    +
    bury 7
    b test_nested_array_for_header@10

test_nested_array_after_for@13:
    // tests/artifacts/Arrays/immutable.py:259
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    dig 10
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bit_packed_tuples[routing]() -> void:
test_bit_packed_tuples:
    // tests/artifacts/Arrays/immutable.py:279
    // arr2 = ImmutableArray[TwoBoolTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:280-282
    // arr7 = ImmutableArray[SevenBoolTuple]()
    // arr8 = ImmutableArray[EightBoolTuple]()
    // arr9 = ImmutableArray[NineBoolTuple]()
    dupn 3
    // tests/artifacts/Arrays/immutable.py:288
    // for i in urange(5):
    intc_0 // 0

test_bit_packed_tuples_for_header@2:
    // tests/artifacts/Arrays/immutable.py:288
    // for i in urange(5):
    dup
    pushint 5
    <
    bz test_bit_packed_tuples_after_for@5
    // tests/artifacts/Arrays/immutable.py:289
    // arr2 = arr2.append(TwoBoolTuple(a=i == 0, b=i == 1))
    dupn 2
    !
    dig 1
    intc_1 // 1
    ==
    bytec_3 // 0x00
    intc_0 // 0
    uncover 3
    setbit
    intc_1 // 1
    uncover 2
    setbit
    dig 6
    dup
    cover 2
    dig 1
    concat // on error: max array length exceeded
    uncover 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 7
    // tests/artifacts/Arrays/immutable.py:293
    // bar=i + 1,
    dig 1
    intc_1 // 1
    +
    // tests/artifacts/Arrays/immutable.py:296
    // c=i == 2,
    dig 2
    intc_2 // 2
    ==
    // tests/artifacts/Arrays/immutable.py:297
    // d=i == 3,
    dig 3
    pushint 3
    ==
    // tests/artifacts/Arrays/immutable.py:298
    // e=i == 4,
    dig 4
    pushint 4
    ==
    // tests/artifacts/Arrays/immutable.py:299
    // f=i == 5,
    dig 5
    pushint 5
    ==
    // tests/artifacts/Arrays/immutable.py:300
    // g=i == 6,
    dig 6
    pushint 6
    ==
    // tests/artifacts/Arrays/immutable.py:290-302
    // arr7 = arr7.append(
    //     SevenBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //     )
    // )
    dig 7
    itob
    uncover 7
    intc_2 // 2
    uncover 7
    setbit
    pushint 3
    uncover 6
    setbit
    pushint 4
    uncover 5
    setbit
    pushint 5
    uncover 4
    setbit
    pushint 6
    uncover 3
    setbit
    dup2
    concat
    dig 3
    itob
    swap
    dig 1
    concat
    dig 9
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 9
    // tests/artifacts/Arrays/immutable.py:314
    // h=i == 7,
    dig 4
    pushint 7
    ==
    // tests/artifacts/Arrays/immutable.py:303-316
    // arr8 = arr8.append(
    //     EightBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //     )
    // )
    uncover 2
    pushint 7
    uncover 2
    setbit
    uncover 2
    swap
    concat
    dup
    dig 2
    concat
    dig 7
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 7
    // tests/artifacts/Arrays/immutable.py:329
    // i=i == 8,
    uncover 3
    intc_3 // 8
    ==
    // tests/artifacts/Arrays/immutable.py:317-331
    // arr9 = arr9.append(
    //     NineBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //         i=i == 8,
    //     )
    // )
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat
    swap
    concat
    dig 3
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 3
    bury 1
    b test_bit_packed_tuples_for_header@2

test_bit_packed_tuples_after_for@5:
    // tests/artifacts/Arrays/immutable.py:333
    // assert arr2.length == 5
    dig 4
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    pushint 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:334
    // assert arr7.length == 5
    dig 4
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    pushint 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:335
    // assert arr8.length == 5
    dig 4
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    pushint 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:336
    // assert arr9.length == 5
    dig 4
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    pushint 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:337
    // self.bool2 = arr2
    pushbytes "bool2"
    uncover 4
    app_global_put
    // tests/artifacts/Arrays/immutable.py:338
    // self.bool7 = arr7
    pushbytes "bool7"
    uncover 3
    app_global_put
    // tests/artifacts/Arrays/immutable.py:339
    // self.bool8 = arr8
    pushbytes "bool8"
    uncover 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:340
    // self.bool9 = arr9
    pushbytes "bool9"
    swap
    app_global_put
    // tests/artifacts/Arrays/immutable.py:277
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.sum_uints_and_lengths_and_trues[routing]() -> void:
sum_uints_and_lengths_and_trues:
    bytec_0 // ""
    dupn 6
    // tests/artifacts/Arrays/immutable.py:342
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arrays/immutable.py:350
    // sum1 = sum2 = sum3 = sum4 = UInt64()
    intc_0 // 0
    dupn 3
    // tests/artifacts/Arrays/immutable.py:342
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:351
    // for i in arr1:
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    intc_0 // 0

sum_uints_and_lengths_and_trues_for_header@2:
    // tests/artifacts/Arrays/immutable.py:351
    // for i in arr1:
    dup
    dig 2
    <
    bz sum_uints_and_lengths_and_trues_after_for@5
    dig 9
    extract 2 0
    dig 1
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:352
    // sum1 += i
    dig 4
    +
    bury 4
    intc_1 // 1
    +
    bury 1
    b sum_uints_and_lengths_and_trues_for_header@2

sum_uints_and_lengths_and_trues_after_for@5:
    // tests/artifacts/Arrays/immutable.py:353
    // for b in arr2:
    dig 8
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    bury 17
    intc_0 // 0
    bury 13

sum_uints_and_lengths_and_trues_for_header@6:
    // tests/artifacts/Arrays/immutable.py:353
    // for b in arr2:
    dig 12
    dig 17
    <
    bz sum_uints_and_lengths_and_trues_after_for@11
    dig 12
    pushint 16
    +
    dig 9
    swap
    getbit
    // tests/artifacts/Arrays/immutable.py:354
    // if b:
    bz sum_uints_and_lengths_and_trues_after_if_else@9
    // tests/artifacts/Arrays/immutable.py:355
    // sum2 += 1
    dig 3
    intc_1 // 1
    +
    bury 4

sum_uints_and_lengths_and_trues_after_if_else@9:
    dig 12
    intc_1 // 1
    +
    bury 13
    b sum_uints_and_lengths_and_trues_for_header@6

sum_uints_and_lengths_and_trues_after_for@11:
    // tests/artifacts/Arrays/immutable.py:356
    // for tup in arr3:
    dig 7
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    bury 16
    intc_0 // 0
    bury 12

sum_uints_and_lengths_and_trues_for_header@12:
    // tests/artifacts/Arrays/immutable.py:356
    // for tup in arr3:
    dig 11
    dig 16
    <
    bz sum_uints_and_lengths_and_trues_after_for@19
    dig 7
    extract 2 0
    dig 12
    pushint 9
    *
    pushint 9
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64
    getbit
    uncover 2
    pushint 65
    getbit
    bury 13
    // tests/artifacts/Arrays/immutable.py:357
    // sum3 += tup.foo
    dig 6
    uncover 2
    +
    bury 6
    // tests/artifacts/Arrays/immutable.py:358
    // if tup.bar:
    bz sum_uints_and_lengths_and_trues_after_if_else@15
    // tests/artifacts/Arrays/immutable.py:359
    // sum3 += 1
    dig 4
    intc_1 // 1
    +
    bury 5

sum_uints_and_lengths_and_trues_after_if_else@15:
    // tests/artifacts/Arrays/immutable.py:360
    // if tup.baz:
    dig 10
    bz sum_uints_and_lengths_and_trues_after_if_else@17
    // tests/artifacts/Arrays/immutable.py:361
    // sum3 += 1
    dig 4
    intc_1 // 1
    +
    bury 5

sum_uints_and_lengths_and_trues_after_if_else@17:
    dig 11
    intc_1 // 1
    +
    bury 12
    b sum_uints_and_lengths_and_trues_for_header@12

sum_uints_and_lengths_and_trues_after_for@19:
    // tests/artifacts/Arrays/immutable.py:362
    // for idx, dyn_tup in uenumerate(arr4):
    dig 6
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    bury 15
    intc_0 // 0
    bury 14

sum_uints_and_lengths_and_trues_for_header@20:
    // tests/artifacts/Arrays/immutable.py:362
    // for idx, dyn_tup in uenumerate(arr4):
    dig 13
    dig 15
    <
    bz sum_uints_and_lengths_and_trues_after_for@23
    dig 6
    extract 2 0
    dig 14
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    dig 18
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:363
    // sum4 += dyn_tup.foo
    dig 9
    uncover 2
    +
    // tests/artifacts/Arrays/immutable.py:364
    // sum4 += dyn_tup.bar.bytes.length
    swap
    len
    swap
    dig 1
    +
    bury 9
    // tests/artifacts/Arrays/immutable.py:365
    // assert dyn_tup.bar.bytes.length == idx, "expected string length to match index"
    uncover 2
    ==
    assert // expected string length to match index
    bury 14
    b sum_uints_and_lengths_and_trues_for_header@20

sum_uints_and_lengths_and_trues_after_for@23:
    // tests/artifacts/Arrays/immutable.py:342
    // @arc4.abimethod()
    dig 2
    itob
    dig 4
    itob
    concat
    dig 5
    itob
    concat
    dig 6
    itob
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_return[routing]() -> void:
test_uint64_return:
    // tests/artifacts/Arrays/immutable.py:369
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:371
    // arr = ImmutableArray((UInt64(1), UInt64(2), UInt64(3)))
    pushbytes 0x0003000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/immutable.py:372
    // for i in urange(append):
    intc_0 // 0

test_uint64_return_for_header@2:
    // tests/artifacts/Arrays/immutable.py:372
    // for i in urange(append):
    dup
    dig 3
    <
    bz test_uint64_return_after_for@5
    // tests/artifacts/Arrays/immutable.py:373
    // arr = arr.append(i)
    dupn 2
    itob
    dig 3
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 3
    // tests/artifacts/Arrays/immutable.py:372
    // for i in urange(append):
    intc_1 // 1
    +
    bury 1
    b test_uint64_return_for_header@2

test_uint64_return_after_for@5:
    // tests/artifacts/Arrays/immutable.py:369
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    dig 2
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_return[routing]() -> void:
test_bool_return:
    // tests/artifacts/Arrays/immutable.py:376
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:378
    // arr = ImmutableArray((True, False, True, False, True))
    pushbytes 0x0005a8
    // tests/artifacts/Arrays/immutable.py:379
    // for i in urange(append):
    intc_0 // 0

test_bool_return_for_header@2:
    // tests/artifacts/Arrays/immutable.py:379
    // for i in urange(append):
    dup
    dig 3
    <
    bz test_bool_return_after_for@5
    // tests/artifacts/Arrays/immutable.py:380
    // arr = arr.append(i % 2 == 0)
    dupn 2
    intc_2 // 2
    %
    !
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    dig 3
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    bury 3
    // tests/artifacts/Arrays/immutable.py:379
    // for i in urange(append):
    intc_1 // 1
    +
    bury 1
    b test_bool_return_for_header@2

test_bool_return_after_for@5:
    // tests/artifacts/Arrays/immutable.py:376
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    dig 2
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_tuple_return[routing]() -> void:
test_tuple_return:
    // tests/artifacts/Arrays/immutable.py:383
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:385
    // arr = ImmutableArray((MyTuple(UInt64(), True, False),))
    pushbytes 0x0001000000000000000080
    // tests/artifacts/Arrays/immutable.py:386
    // for i in urange(append):
    intc_0 // 0

test_tuple_return_for_header@2:
    // tests/artifacts/Arrays/immutable.py:386
    // for i in urange(append):
    dup
    dig 3
    <
    bz test_tuple_return_after_for@5
    // tests/artifacts/Arrays/immutable.py:387
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    dupn 2
    intc_2 // 2
    %
    !
    dig 1
    pushint 3
    %
    !
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    dig 3
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    bury 3
    // tests/artifacts/Arrays/immutable.py:386
    // for i in urange(append):
    intc_1 // 1
    +
    bury 1
    b test_tuple_return_for_header@2

test_tuple_return_after_for@5:
    // tests/artifacts/Arrays/immutable.py:383
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    dig 2
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_tuple_return[routing]() -> void:
test_dynamic_tuple_return:
    // tests/artifacts/Arrays/immutable.py:390
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:392
    // arr = ImmutableArray((MyDynamicSizedTuple(UInt64(), String("Hello")),))
    pushbytes 0x000100020000000000000000000a000548656c6c6f
    // tests/artifacts/Arrays/immutable.py:393
    // for i in urange(append):
    intc_0 // 0

test_dynamic_tuple_return_for_header@2:
    // tests/artifacts/Arrays/immutable.py:393
    // for i in urange(append):
    dup
    dig 3
    <
    bz test_dynamic_tuple_return_after_for@5
    // tests/artifacts/Arrays/immutable.py:394
    // arr = arr.append(MyDynamicSizedTuple(i, times(i)))
    dupn 2
    callsub times
    dig 3
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    bury 3
    // tests/artifacts/Arrays/immutable.py:393
    // for i in urange(append):
    intc_1 // 1
    +
    bury 1
    b test_dynamic_tuple_return_for_header@2

test_dynamic_tuple_return_after_for@5:
    // tests/artifacts/Arrays/immutable.py:390
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    dig 2
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_convert_to_array_and_back[routing]() -> void:
test_convert_to_array_and_back:
    // tests/artifacts/Arrays/immutable.py:397
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    swap
    // tests/artifacts/Arrays/immutable.py:402
    // mutable.extend(arr)
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:403
    // for i in urange(append):
    intc_0 // 0

test_convert_to_array_and_back_for_header@2:
    // tests/artifacts/Arrays/immutable.py:403
    // for i in urange(append):
    dup
    dig 3
    <
    bz test_convert_to_array_and_back_after_for@5
    // tests/artifacts/Arrays/immutable.py:404
    // mutable.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    dupn 2
    intc_2 // 2
    %
    !
    dig 1
    pushint 3
    %
    !
    dig 4
    cover 3
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    uncover 2
    swap
    concat // on error: max array length exceeded
    bury 3
    // tests/artifacts/Arrays/immutable.py:403
    // for i in urange(append):
    intc_1 // 1
    +
    bury 1
    b test_convert_to_array_and_back_for_header@2

test_convert_to_array_and_back_after_for@5:
    dig 1
    // tests/artifacts/Arrays/immutable.py:405
    // return mutable.freeze()
    dup
    len
    pushint 9
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/immutable.py:397
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_arc4_tuple[routing]() -> void:
test_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:411
    // prefix = ImmutableArray((arc4.UInt64(1), arc4.UInt64(2)))
    bytec 8 // 0x000200000000000000010000000000000002
    // tests/artifacts/Arrays/immutable.py:407
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:412
    // result = prefix + arg
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:407
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_native_tuple[routing]() -> void:
test_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:415
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    extract 0 8
    swap
    extract 8 8
    // tests/artifacts/Arrays/immutable.py:420
    // result = prefix + arg
    concat
    // tests/artifacts/Arrays/immutable.py:419
    // prefix = ImmutableArray((arc4.UInt64(1), arc4.UInt64(2)))
    bytec 8 // 0x000200000000000000010000000000000002
    // tests/artifacts/Arrays/immutable.py:420
    // result = prefix + arg
    swap
    concat // on error: max array length exceeded
    pushbytes 0x0004
    replace2 0
    // tests/artifacts/Arrays/immutable.py:415
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_arc4_tuple[routing]() -> void:
test_dynamic_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:423
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:428
    // result = prefix + arg
    extract 4 0
    // tests/artifacts/Arrays/immutable.py:427
    // prefix = ImmutableArray((arc4.String("a"), arc4.String("b")))
    bytec 9 // 0x000200040007000161000162
    // tests/artifacts/Arrays/immutable.py:428
    // result = prefix + arg
    swap
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:423
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_native_tuple[routing]() -> void:
test_dynamic_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:431
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    dig 1
    intc_2 // 2
    extract_uint16
    dig 2
    uncover 2
    dig 2
    substring3
    dig 2
    len
    uncover 3
    uncover 3
    uncover 2
    substring3
    // tests/artifacts/Arrays/immutable.py:436
    // result = prefix + arg
    concat
    // tests/artifacts/Arrays/immutable.py:435
    // prefix = ImmutableArray((arc4.String("a"), arc4.String("b")))
    bytec 9 // 0x000200040007000161000162
    // tests/artifacts/Arrays/immutable.py:436
    // result = prefix + arg
    swap
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:431
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_immutable_dynamic[routing]() -> void:
test_concat_immutable_dynamic:
    // tests/artifacts/Arrays/immutable.py:439
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:443
    // return imm1 + imm2
    dig 1
    intc_0 // 0
    extract_uint16
    uncover 2
    extract 2 0
    dig 2
    extract 2 0
    uncover 3
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    uncover 3
    uncover 3
    uncover 2
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    // tests/artifacts/Arrays/immutable.py:439
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_immutable_arc4[routing]() -> void:
test_immutable_arc4:
    // tests/artifacts/Arrays/immutable.py:445
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:447
    // assert imm, "expected non empty array"
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    assert // expected non empty array
    // tests/artifacts/Arrays/immutable.py:448
    // imm = imm.replace(imm.length - 1, imm[0])
    intc_1 // 1
    -
    dig 1
    extract 2 16
    swap
    pushint 16
    *
    intc_2 // 2
    +
    swap
    replace3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:445
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_imm_fixed_arr[routing]() -> void:
test_imm_fixed_arr:
    bytec_0 // ""
    // tests/artifacts/Arrays/immutable.py:453
    // arr1 = zero_bytes(NativeStruct3)
    pushint 48
    bzero
    dup
    // tests/artifacts/Arrays/immutable.py:454
    // struct12 = NativeStruct(Txn.num_app_args + 1, Txn.num_app_args + 2)
    txn NumAppArgs
    intc_1 // 1
    +
    txn NumAppArgs
    intc_2 // 2
    +
    swap
    itob
    swap
    itob
    concat
    dup
    cover 2
    // tests/artifacts/Arrays/immutable.py:455
    // arr2 = NativeStruct3((struct12, struct12, struct12))
    dup
    dig 1
    concat
    swap
    concat
    dup
    cover 2
    // tests/artifacts/Arrays/immutable.py:457
    // assert arr1 != arr2, "expected arrays to be different"
    !=
    assert // expected arrays to be different
    // tests/artifacts/Arrays/immutable.py:460
    // for i in urange(3):
    intc_0 // 0

test_imm_fixed_arr_for_header@2:
    // tests/artifacts/Arrays/immutable.py:460
    // for i in urange(3):
    dup
    pushint 3
    <
    bz test_imm_fixed_arr_after_for@5
    // tests/artifacts/Arrays/immutable.py:461
    // arr1 = arr1.replace(i, struct12)
    dupn 2
    pushint 16
    *
    dig 5
    swap
    dig 5
    replace3 // on error: index access is out of bounds
    bury 5
    // tests/artifacts/Arrays/immutable.py:460
    // for i in urange(3):
    intc_1 // 1
    +
    bury 1
    b test_imm_fixed_arr_for_header@2

test_imm_fixed_arr_after_for@5:
    // tests/artifacts/Arrays/immutable.py:463
    // assert arr1 == arr2, "expected arrays to be the same"
    dig 3
    dig 2
    ==
    assert // expected arrays to be the same
    intc_0 // 0
    bury 5

test_imm_fixed_arr_for_header@6:
    // tests/artifacts/Arrays/immutable.py:465
    // for struct_it in arr1:
    dig 4
    pushint 3
    <
    bz test_imm_fixed_arr_after_for@9
    dig 4
    dup
    pushint 16
    *
    dig 5
    swap
    pushint 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:466
    // assert struct_it == struct12, "expected items on iteration to be the same"
    dig 4
    ==
    assert // expected items on iteration to be the same
    intc_1 // 1
    +
    bury 5
    b test_imm_fixed_arr_for_header@6

test_imm_fixed_arr_after_for@9:
    // tests/artifacts/Arrays/immutable.py:468
    // self.imm_fixed_arr = arr1
    bytec 10 // "imm_fixed_arr"
    dig 4
    dup
    cover 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:472
    // assert sum_imm_fixed(mut_arr.freeze()) == 15, "expected sum to be 15"
    dup
    callsub sum_imm_fixed
    pushint 15
    ==
    assert // expected sum to be 15
    // tests/artifacts/Arrays/immutable.py:474
    // mut_arr[0] = NativeStruct(UInt64(), UInt64())
    pushbytes 0x00000000000000000000000000000000
    replace2 0 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:475
    // assert sum_imm_fixed(mut_arr.freeze()) == 10, "expected sum to be 10"
    callsub sum_imm_fixed
    pushint 10
    ==
    assert // expected sum to be 10
    // tests/artifacts/Arrays/immutable.py:477
    // return self.imm_fixed_arr
    intc_0 // 0
    bytec 10 // "imm_fixed_arr"
    app_global_get_ex
    assert // check self.imm_fixed_arr exists
    // tests/artifacts/Arrays/immutable.py:451
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"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","clear":"C4EBQw=="},"events":[{"name":"emit_test","args":[{"type":"uint64[]","name":"field1"}]}],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the ImmutableArrayContract contract + */ +export type ImmutableArrayContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'test_uint64_array()void': Record + 'test_biguint_array()void': Record + 'test_bool_array(uint64)void': { + length: bigint | number + } + 'test_fixed_size_tuple_array()void': Record + 'test_fixed_size_named_tuple_array()void': Record + 'test_dynamic_sized_tuple_array()void': Record + 'test_dynamic_sized_named_tuple_array()void': Record + 'test_implicit_conversion_log(uint64[])void': { + arr: bigint[] | number[] + } + 'test_implicit_conversion_emit(uint64[])void': { + arr: bigint[] | number[] + } + 'test_nested_array(uint64,uint64[][])uint64[]': { + arrToAdd: bigint | number + arr: bigint[] | number[][] + } + 'test_bit_packed_tuples()void': Record + 'sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)': { + arr1: bigint[] | number[] + arr2: boolean[] + arr3: [bigint | number, boolean, boolean][] + arr4: [bigint | number, string][] + } + 'test_uint64_return(uint64)uint64[]': { + append: bigint | number + } + 'test_bool_return(uint64)bool[]': { + append: bigint | number + } + 'test_tuple_return(uint64)(uint64,bool,bool)[]': { + append: bigint | number + } + 'test_dynamic_tuple_return(uint64)(uint64,string)[]': { + append: bigint | number + } + 'test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]': { + arr: [bigint | number, boolean, boolean][] + append: bigint | number + } + 'test_concat_with_arc4_tuple((uint64,uint64))uint64[]': { + arg: [bigint | number, bigint | number] + } + 'test_concat_with_native_tuple((uint64,uint64))uint64[]': { + arg: [bigint | number, bigint | number] + } + 'test_dynamic_concat_with_arc4_tuple((string,string))string[]': { + arg: [string, string] + } + 'test_dynamic_concat_with_native_tuple((string,string))string[]': { + arg: [string, string] + } + 'test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]': { + imm1: [bigint | number, string][] + imm2: [bigint | number, string][] + } + 'test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]': { + imm: [bigint | number, bigint | number][] + } + 'test_imm_fixed_arr()(uint64,uint64)[3]': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'test_uint64_array()void': [] + 'test_biguint_array()void': [] + 'test_bool_array(uint64)void': [length: bigint | number] + 'test_fixed_size_tuple_array()void': [] + 'test_fixed_size_named_tuple_array()void': [] + 'test_dynamic_sized_tuple_array()void': [] + 'test_dynamic_sized_named_tuple_array()void': [] + 'test_implicit_conversion_log(uint64[])void': [arr: bigint[] | number[]] + 'test_implicit_conversion_emit(uint64[])void': [arr: bigint[] | number[]] + 'test_nested_array(uint64,uint64[][])uint64[]': [arrToAdd: bigint | number, arr: bigint[] | number[][]] + 'test_bit_packed_tuples()void': [] + 'sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)': [arr1: bigint[] | number[], arr2: boolean[], arr3: [bigint | number, boolean, boolean][], arr4: [bigint | number, string][]] + 'test_uint64_return(uint64)uint64[]': [append: bigint | number] + 'test_bool_return(uint64)bool[]': [append: bigint | number] + 'test_tuple_return(uint64)(uint64,bool,bool)[]': [append: bigint | number] + 'test_dynamic_tuple_return(uint64)(uint64,string)[]': [append: bigint | number] + 'test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]': [arr: [bigint | number, boolean, boolean][], append: bigint | number] + 'test_concat_with_arc4_tuple((uint64,uint64))uint64[]': [arg: [bigint | number, bigint | number]] + 'test_concat_with_native_tuple((uint64,uint64))uint64[]': [arg: [bigint | number, bigint | number]] + 'test_dynamic_concat_with_arc4_tuple((string,string))string[]': [arg: [string, string]] + 'test_dynamic_concat_with_native_tuple((string,string))string[]': [arg: [string, string]] + 'test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]': [imm1: [bigint | number, string][], imm2: [bigint | number, string][]] + 'test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]': [imm: [bigint | number, bigint | number][]] + 'test_imm_fixed_arr()(uint64,uint64)[3]': [] + } +} + +/** + * The return type for each method + */ +export type ImmutableArrayContractReturns = { + 'test_uint64_array()void': void + 'test_biguint_array()void': void + 'test_bool_array(uint64)void': void + 'test_fixed_size_tuple_array()void': void + 'test_fixed_size_named_tuple_array()void': void + 'test_dynamic_sized_tuple_array()void': void + 'test_dynamic_sized_named_tuple_array()void': void + 'test_implicit_conversion_log(uint64[])void': void + 'test_implicit_conversion_emit(uint64[])void': void + 'test_nested_array(uint64,uint64[][])uint64[]': bigint[] + 'test_bit_packed_tuples()void': void + 'sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)': [bigint, bigint, bigint, bigint] + 'test_uint64_return(uint64)uint64[]': bigint[] + 'test_bool_return(uint64)bool[]': boolean[] + 'test_tuple_return(uint64)(uint64,bool,bool)[]': [bigint, boolean, boolean][] + 'test_dynamic_tuple_return(uint64)(uint64,string)[]': [bigint, string][] + 'test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]': [bigint, boolean, boolean][] + 'test_concat_with_arc4_tuple((uint64,uint64))uint64[]': bigint[] + 'test_concat_with_native_tuple((uint64,uint64))uint64[]': bigint[] + 'test_dynamic_concat_with_arc4_tuple((string,string))string[]': string[] + 'test_dynamic_concat_with_native_tuple((string,string))string[]': string[] + 'test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]': [bigint, string][] + 'test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]': [bigint, bigint][] + 'test_imm_fixed_arr()(uint64,uint64)[3]': [[bigint, bigint], [bigint, bigint], [bigint, bigint]] +} + +/** + * Defines the types of available calls and state of the ImmutableArrayContract smart contract. + */ +export type ImmutableArrayContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'test_uint64_array()void' | 'test_uint64_array', { + argsObj: ImmutableArrayContractArgs['obj']['test_uint64_array()void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_uint64_array()void'] + returns: ImmutableArrayContractReturns['test_uint64_array()void'] + }> + & Record<'test_biguint_array()void' | 'test_biguint_array', { + argsObj: ImmutableArrayContractArgs['obj']['test_biguint_array()void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_biguint_array()void'] + returns: ImmutableArrayContractReturns['test_biguint_array()void'] + }> + & Record<'test_bool_array(uint64)void' | 'test_bool_array', { + argsObj: ImmutableArrayContractArgs['obj']['test_bool_array(uint64)void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_bool_array(uint64)void'] + returns: ImmutableArrayContractReturns['test_bool_array(uint64)void'] + }> + & Record<'test_fixed_size_tuple_array()void' | 'test_fixed_size_tuple_array', { + argsObj: ImmutableArrayContractArgs['obj']['test_fixed_size_tuple_array()void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_fixed_size_tuple_array()void'] + returns: ImmutableArrayContractReturns['test_fixed_size_tuple_array()void'] + }> + & Record<'test_fixed_size_named_tuple_array()void' | 'test_fixed_size_named_tuple_array', { + argsObj: ImmutableArrayContractArgs['obj']['test_fixed_size_named_tuple_array()void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_fixed_size_named_tuple_array()void'] + returns: ImmutableArrayContractReturns['test_fixed_size_named_tuple_array()void'] + }> + & Record<'test_dynamic_sized_tuple_array()void' | 'test_dynamic_sized_tuple_array', { + argsObj: ImmutableArrayContractArgs['obj']['test_dynamic_sized_tuple_array()void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_dynamic_sized_tuple_array()void'] + returns: ImmutableArrayContractReturns['test_dynamic_sized_tuple_array()void'] + }> + & Record<'test_dynamic_sized_named_tuple_array()void' | 'test_dynamic_sized_named_tuple_array', { + argsObj: ImmutableArrayContractArgs['obj']['test_dynamic_sized_named_tuple_array()void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_dynamic_sized_named_tuple_array()void'] + returns: ImmutableArrayContractReturns['test_dynamic_sized_named_tuple_array()void'] + }> + & Record<'test_implicit_conversion_log(uint64[])void' | 'test_implicit_conversion_log', { + argsObj: ImmutableArrayContractArgs['obj']['test_implicit_conversion_log(uint64[])void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_implicit_conversion_log(uint64[])void'] + returns: ImmutableArrayContractReturns['test_implicit_conversion_log(uint64[])void'] + }> + & Record<'test_implicit_conversion_emit(uint64[])void' | 'test_implicit_conversion_emit', { + argsObj: ImmutableArrayContractArgs['obj']['test_implicit_conversion_emit(uint64[])void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_implicit_conversion_emit(uint64[])void'] + returns: ImmutableArrayContractReturns['test_implicit_conversion_emit(uint64[])void'] + }> + & Record<'test_nested_array(uint64,uint64[][])uint64[]' | 'test_nested_array', { + argsObj: ImmutableArrayContractArgs['obj']['test_nested_array(uint64,uint64[][])uint64[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_nested_array(uint64,uint64[][])uint64[]'] + returns: ImmutableArrayContractReturns['test_nested_array(uint64,uint64[][])uint64[]'] + }> + & Record<'test_bit_packed_tuples()void' | 'test_bit_packed_tuples', { + argsObj: ImmutableArrayContractArgs['obj']['test_bit_packed_tuples()void'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_bit_packed_tuples()void'] + returns: ImmutableArrayContractReturns['test_bit_packed_tuples()void'] + }> + & Record<'sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)' | 'sum_uints_and_lengths_and_trues', { + argsObj: ImmutableArrayContractArgs['obj']['sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)'] + argsTuple: ImmutableArrayContractArgs['tuple']['sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)'] + returns: ImmutableArrayContractReturns['sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)'] + }> + & Record<'test_uint64_return(uint64)uint64[]' | 'test_uint64_return', { + argsObj: ImmutableArrayContractArgs['obj']['test_uint64_return(uint64)uint64[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_uint64_return(uint64)uint64[]'] + returns: ImmutableArrayContractReturns['test_uint64_return(uint64)uint64[]'] + }> + & Record<'test_bool_return(uint64)bool[]' | 'test_bool_return', { + argsObj: ImmutableArrayContractArgs['obj']['test_bool_return(uint64)bool[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_bool_return(uint64)bool[]'] + returns: ImmutableArrayContractReturns['test_bool_return(uint64)bool[]'] + }> + & Record<'test_tuple_return(uint64)(uint64,bool,bool)[]' | 'test_tuple_return', { + argsObj: ImmutableArrayContractArgs['obj']['test_tuple_return(uint64)(uint64,bool,bool)[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_tuple_return(uint64)(uint64,bool,bool)[]'] + returns: ImmutableArrayContractReturns['test_tuple_return(uint64)(uint64,bool,bool)[]'] + }> + & Record<'test_dynamic_tuple_return(uint64)(uint64,string)[]' | 'test_dynamic_tuple_return', { + argsObj: ImmutableArrayContractArgs['obj']['test_dynamic_tuple_return(uint64)(uint64,string)[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_dynamic_tuple_return(uint64)(uint64,string)[]'] + returns: ImmutableArrayContractReturns['test_dynamic_tuple_return(uint64)(uint64,string)[]'] + }> + & Record<'test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]' | 'test_convert_to_array_and_back', { + argsObj: ImmutableArrayContractArgs['obj']['test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]'] + returns: ImmutableArrayContractReturns['test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]'] + }> + & Record<'test_concat_with_arc4_tuple((uint64,uint64))uint64[]' | 'test_concat_with_arc4_tuple', { + argsObj: ImmutableArrayContractArgs['obj']['test_concat_with_arc4_tuple((uint64,uint64))uint64[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_concat_with_arc4_tuple((uint64,uint64))uint64[]'] + returns: ImmutableArrayContractReturns['test_concat_with_arc4_tuple((uint64,uint64))uint64[]'] + }> + & Record<'test_concat_with_native_tuple((uint64,uint64))uint64[]' | 'test_concat_with_native_tuple', { + argsObj: ImmutableArrayContractArgs['obj']['test_concat_with_native_tuple((uint64,uint64))uint64[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_concat_with_native_tuple((uint64,uint64))uint64[]'] + returns: ImmutableArrayContractReturns['test_concat_with_native_tuple((uint64,uint64))uint64[]'] + }> + & Record<'test_dynamic_concat_with_arc4_tuple((string,string))string[]' | 'test_dynamic_concat_with_arc4_tuple', { + argsObj: ImmutableArrayContractArgs['obj']['test_dynamic_concat_with_arc4_tuple((string,string))string[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_dynamic_concat_with_arc4_tuple((string,string))string[]'] + returns: ImmutableArrayContractReturns['test_dynamic_concat_with_arc4_tuple((string,string))string[]'] + }> + & Record<'test_dynamic_concat_with_native_tuple((string,string))string[]' | 'test_dynamic_concat_with_native_tuple', { + argsObj: ImmutableArrayContractArgs['obj']['test_dynamic_concat_with_native_tuple((string,string))string[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_dynamic_concat_with_native_tuple((string,string))string[]'] + returns: ImmutableArrayContractReturns['test_dynamic_concat_with_native_tuple((string,string))string[]'] + }> + & Record<'test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]' | 'test_concat_immutable_dynamic', { + argsObj: ImmutableArrayContractArgs['obj']['test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]'] + returns: ImmutableArrayContractReturns['test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]'] + }> + & Record<'test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]' | 'test_immutable_arc4', { + argsObj: ImmutableArrayContractArgs['obj']['test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]'] + returns: ImmutableArrayContractReturns['test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]'] + }> + & Record<'test_imm_fixed_arr()(uint64,uint64)[3]' | 'test_imm_fixed_arr', { + argsObj: ImmutableArrayContractArgs['obj']['test_imm_fixed_arr()(uint64,uint64)[3]'] + argsTuple: ImmutableArrayContractArgs['tuple']['test_imm_fixed_arr()(uint64,uint64)[3]'] + returns: ImmutableArrayContractReturns['test_imm_fixed_arr()(uint64,uint64)[3]'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + global: { + keys: { + a: bigint[] + g: boolean[] + c: [bigint, bigint][] + d: [bigint, boolean, boolean][] + e: [bigint, Uint8Array][] + f: [bigint, string][] + bool2: [boolean, boolean][] + bool7: [bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] + bool8: [bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] + bool9: [bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] + immFixedArr: [[bigint, bigint], [bigint, bigint], [bigint, bigint]] + } + maps: {} + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type ImmutableArrayContractSignatures = keyof ImmutableArrayContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type ImmutableArrayContractNonVoidMethodSignatures = keyof ImmutableArrayContractTypes['methods'] extends infer T ? T extends keyof ImmutableArrayContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the ImmutableArrayContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = ImmutableArrayContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the ImmutableArrayContract smart contract to the method's return type + */ +export type MethodReturn = ImmutableArrayContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed global state of the application. + */ +export type GlobalKeysState = ImmutableArrayContractTypes['state']['global']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type ImmutableArrayContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type ImmutableArrayContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: ImmutableArrayContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the ImmutableArrayContract smart contract + */ +export abstract class ImmutableArrayContractParamsFactory { + /** + * Constructs a no op call for the test_uint64_array()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testUint64Array(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_uint64_array()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_biguint_array()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testBiguintArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_biguint_array()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_bool_array(uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testBoolArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_bool_array(uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.length], + } + } + /** + * Constructs a no op call for the test_fixed_size_tuple_array()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testFixedSizeTupleArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_fixed_size_tuple_array()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_fixed_size_named_tuple_array()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testFixedSizeNamedTupleArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_fixed_size_named_tuple_array()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_dynamic_sized_tuple_array()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testDynamicSizedTupleArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_dynamic_sized_tuple_array()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_dynamic_sized_named_tuple_array()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testDynamicSizedNamedTupleArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_dynamic_sized_named_tuple_array()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_implicit_conversion_log(uint64[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testImplicitConversionLog(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_implicit_conversion_log(uint64[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arr], + } + } + /** + * Constructs a no op call for the test_implicit_conversion_emit(uint64[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testImplicitConversionEmit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_implicit_conversion_emit(uint64[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arr], + } + } + /** + * Constructs a no op call for the test_nested_array(uint64,uint64[][])uint64[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testNestedArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_nested_array(uint64,uint64[][])uint64[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arrToAdd, params.args.arr], + } + } + /** + * Constructs a no op call for the test_bit_packed_tuples()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testBitPackedTuples(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_bit_packed_tuples()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static sumUintsAndLengthsAndTrues(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arr1, params.args.arr2, params.args.arr3, params.args.arr4], + } + } + /** + * Constructs a no op call for the test_uint64_return(uint64)uint64[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testUint64Return(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_uint64_return(uint64)uint64[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.append], + } + } + /** + * Constructs a no op call for the test_bool_return(uint64)bool[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testBoolReturn(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_bool_return(uint64)bool[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.append], + } + } + /** + * Constructs a no op call for the test_tuple_return(uint64)(uint64,bool,bool)[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testTupleReturn(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_tuple_return(uint64)(uint64,bool,bool)[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.append], + } + } + /** + * Constructs a no op call for the test_dynamic_tuple_return(uint64)(uint64,string)[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testDynamicTupleReturn(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_dynamic_tuple_return(uint64)(uint64,string)[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.append], + } + } + /** + * Constructs a no op call for the test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testConvertToArrayAndBack(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arr, params.args.append], + } + } + /** + * Constructs a no op call for the test_concat_with_arc4_tuple((uint64,uint64))uint64[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testConcatWithArc4Tuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_concat_with_arc4_tuple((uint64,uint64))uint64[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arg], + } + } + /** + * Constructs a no op call for the test_concat_with_native_tuple((uint64,uint64))uint64[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testConcatWithNativeTuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_concat_with_native_tuple((uint64,uint64))uint64[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arg], + } + } + /** + * Constructs a no op call for the test_dynamic_concat_with_arc4_tuple((string,string))string[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testDynamicConcatWithArc4Tuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_dynamic_concat_with_arc4_tuple((string,string))string[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arg], + } + } + /** + * Constructs a no op call for the test_dynamic_concat_with_native_tuple((string,string))string[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testDynamicConcatWithNativeTuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_dynamic_concat_with_native_tuple((string,string))string[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arg], + } + } + /** + * Constructs a no op call for the test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testConcatImmutableDynamic(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.imm1, params.args.imm2], + } + } + /** + * Constructs a no op call for the test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testImmutableArc4(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.imm], + } + } + /** + * Constructs a no op call for the test_imm_fixed_arr()(uint64,uint64)[3] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testImmFixedArr(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_imm_fixed_arr()(uint64,uint64)[3]' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the ImmutableArrayContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class ImmutableArrayContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `ImmutableArrayContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new ImmutableArrayContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new ImmutableArrayContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the ImmutableArrayContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: ImmutableArrayContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new ImmutableArrayContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ImmutableArrayContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ImmutableArrayContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ImmutableArrayContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new ImmutableArrayContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the ImmutableArrayContract smart contract + */ +export class ImmutableArrayContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `ImmutableArrayContractClient` + * + * @param appClient An `AppClient` instance which has been created with the ImmutableArrayContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `ImmutableArrayContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `ImmutableArrayContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new ImmutableArrayContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `ImmutableArrayContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new ImmutableArrayContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the ImmutableArrayContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_uint64_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testUint64Array: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testUint64Array(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_biguint_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testBiguintArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testBiguintArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bool_array(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testBoolArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testBoolArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_fixed_size_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testFixedSizeTupleArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testFixedSizeTupleArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_fixed_size_named_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testFixedSizeNamedTupleArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testFixedSizeNamedTupleArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_sized_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testDynamicSizedTupleArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testDynamicSizedTupleArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_sized_named_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testDynamicSizedNamedTupleArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testDynamicSizedNamedTupleArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_implicit_conversion_log(uint64[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testImplicitConversionLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testImplicitConversionLog(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_implicit_conversion_emit(uint64[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testImplicitConversionEmit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testImplicitConversionEmit(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_nested_array(uint64,uint64[][])uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testNestedArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testNestedArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bit_packed_tuples()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testBitPackedTuples: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testBitPackedTuples(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + sumUintsAndLengthsAndTrues: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.sumUintsAndLengthsAndTrues(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_uint64_return(uint64)uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testUint64Return: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testUint64Return(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bool_return(uint64)bool[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testBoolReturn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testBoolReturn(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_tuple_return(uint64)(uint64,bool,bool)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testTupleReturn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testTupleReturn(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_tuple_return(uint64)(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testDynamicTupleReturn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testDynamicTupleReturn(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testConvertToArrayAndBack: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testConvertToArrayAndBack(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_with_arc4_tuple((uint64,uint64))uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testConcatWithArc4Tuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testConcatWithArc4Tuple(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_with_native_tuple((uint64,uint64))uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testConcatWithNativeTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testConcatWithNativeTuple(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_concat_with_arc4_tuple((string,string))string[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testDynamicConcatWithArc4Tuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testDynamicConcatWithArc4Tuple(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_concat_with_native_tuple((string,string))string[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testDynamicConcatWithNativeTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testDynamicConcatWithNativeTuple(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testConcatImmutableDynamic: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testConcatImmutableDynamic(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testImmutableArc4: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testImmutableArc4(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_imm_fixed_arr()(uint64,uint64)[3]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testImmFixedArr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayContractParamsFactory.testImmFixedArr(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the ImmutableArrayContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_uint64_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testUint64Array: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testUint64Array(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_biguint_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testBiguintArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testBiguintArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bool_array(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testBoolArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testBoolArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_fixed_size_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testFixedSizeTupleArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testFixedSizeTupleArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_fixed_size_named_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testFixedSizeNamedTupleArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testFixedSizeNamedTupleArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_sized_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testDynamicSizedTupleArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testDynamicSizedTupleArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_sized_named_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testDynamicSizedNamedTupleArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testDynamicSizedNamedTupleArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_implicit_conversion_log(uint64[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testImplicitConversionLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testImplicitConversionLog(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_implicit_conversion_emit(uint64[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testImplicitConversionEmit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testImplicitConversionEmit(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_nested_array(uint64,uint64[][])uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testNestedArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testNestedArray(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bit_packed_tuples()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testBitPackedTuples: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testBitPackedTuples(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + sumUintsAndLengthsAndTrues: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.sumUintsAndLengthsAndTrues(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_uint64_return(uint64)uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testUint64Return: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testUint64Return(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bool_return(uint64)bool[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testBoolReturn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testBoolReturn(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_tuple_return(uint64)(uint64,bool,bool)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testTupleReturn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testTupleReturn(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_tuple_return(uint64)(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testDynamicTupleReturn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testDynamicTupleReturn(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testConvertToArrayAndBack: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testConvertToArrayAndBack(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_with_arc4_tuple((uint64,uint64))uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testConcatWithArc4Tuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testConcatWithArc4Tuple(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_with_native_tuple((uint64,uint64))uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testConcatWithNativeTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testConcatWithNativeTuple(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_concat_with_arc4_tuple((string,string))string[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testDynamicConcatWithArc4Tuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testDynamicConcatWithArc4Tuple(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_concat_with_native_tuple((string,string))string[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testDynamicConcatWithNativeTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testDynamicConcatWithNativeTuple(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testConcatImmutableDynamic: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testConcatImmutableDynamic(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testImmutableArc4: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testImmutableArc4(params)) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_imm_fixed_arr()(uint64,uint64)[3]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testImmFixedArr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayContractParamsFactory.testImmFixedArr(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the ImmutableArrayContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_uint64_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testUint64Array: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testUint64Array(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_uint64_array()void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_biguint_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testBiguintArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testBiguintArray(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_biguint_array()void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bool_array(uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testBoolArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testBoolArray(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_bool_array(uint64)void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_fixed_size_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testFixedSizeTupleArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testFixedSizeTupleArray(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_fixed_size_tuple_array()void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_fixed_size_named_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testFixedSizeNamedTupleArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testFixedSizeNamedTupleArray(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_fixed_size_named_tuple_array()void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_sized_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testDynamicSizedTupleArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testDynamicSizedTupleArray(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_dynamic_sized_tuple_array()void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_sized_named_tuple_array()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testDynamicSizedNamedTupleArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testDynamicSizedNamedTupleArray(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_dynamic_sized_named_tuple_array()void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_implicit_conversion_log(uint64[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testImplicitConversionLog: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testImplicitConversionLog(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_implicit_conversion_log(uint64[])void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_implicit_conversion_emit(uint64[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testImplicitConversionEmit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testImplicitConversionEmit(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_implicit_conversion_emit(uint64[])void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_nested_array(uint64,uint64[][])uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testNestedArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testNestedArray(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_nested_array(uint64,uint64[][])uint64[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bit_packed_tuples()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testBitPackedTuples: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testBitPackedTuples(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_bit_packed_tuples()void'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + sumUintsAndLengthsAndTrues: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.sumUintsAndLengthsAndTrues(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_uint64_return(uint64)uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testUint64Return: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testUint64Return(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_uint64_return(uint64)uint64[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_bool_return(uint64)bool[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testBoolReturn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testBoolReturn(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_bool_return(uint64)bool[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_tuple_return(uint64)(uint64,bool,bool)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testTupleReturn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testTupleReturn(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_tuple_return(uint64)(uint64,bool,bool)[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_tuple_return(uint64)(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testDynamicTupleReturn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testDynamicTupleReturn(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_dynamic_tuple_return(uint64)(uint64,string)[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testConvertToArrayAndBack: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testConvertToArrayAndBack(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_with_arc4_tuple((uint64,uint64))uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testConcatWithArc4Tuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testConcatWithArc4Tuple(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_concat_with_arc4_tuple((uint64,uint64))uint64[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_with_native_tuple((uint64,uint64))uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testConcatWithNativeTuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testConcatWithNativeTuple(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_concat_with_native_tuple((uint64,uint64))uint64[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_concat_with_arc4_tuple((string,string))string[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testDynamicConcatWithArc4Tuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testDynamicConcatWithArc4Tuple(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_dynamic_concat_with_arc4_tuple((string,string))string[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_dynamic_concat_with_native_tuple((string,string))string[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testDynamicConcatWithNativeTuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testDynamicConcatWithNativeTuple(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_dynamic_concat_with_native_tuple((string,string))string[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testConcatImmutableDynamic: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testConcatImmutableDynamic(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testImmutableArc4: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testImmutableArc4(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]'])} + }, + + /** + * Makes a call to the ImmutableArrayContract smart contract using the `test_imm_fixed_arr()(uint64,uint64)[3]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testImmFixedArr: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayContractParamsFactory.testImmFixedArr(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayContractReturns['test_imm_fixed_arr()(uint64,uint64)[3]'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new ImmutableArrayContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current ImmutableArrayContract app + */ + state = { + /** + * Methods to access global state for the current ImmutableArrayContract app + */ + global: { + /** + * Get all current keyed values from global state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.global.getAll() + return { + a: result.a, + g: result.g, + c: result.c, + d: result.d, + e: result.e, + f: result.f, + bool2: result.bool2, + bool7: result.bool7, + bool8: result.bool8, + bool9: result.bool9, + immFixedArr: result.imm_fixed_arr, + } + }, + /** + * Get the current value of the a key in global state + */ + a: async (): Promise => { return (await this.appClient.state.global.getValue("a")) as bigint[] | undefined }, + /** + * Get the current value of the g key in global state + */ + g: async (): Promise => { return (await this.appClient.state.global.getValue("g")) as boolean[] | undefined }, + /** + * Get the current value of the c key in global state + */ + c: async (): Promise<[bigint, bigint][] | undefined> => { return (await this.appClient.state.global.getValue("c")) as [bigint, bigint][] | undefined }, + /** + * Get the current value of the d key in global state + */ + d: async (): Promise<[bigint, boolean, boolean][] | undefined> => { return (await this.appClient.state.global.getValue("d")) as [bigint, boolean, boolean][] | undefined }, + /** + * Get the current value of the e key in global state + */ + e: async (): Promise<[bigint, Uint8Array][] | undefined> => { return (await this.appClient.state.global.getValue("e")) as [bigint, Uint8Array][] | undefined }, + /** + * Get the current value of the f key in global state + */ + f: async (): Promise<[bigint, string][] | undefined> => { return (await this.appClient.state.global.getValue("f")) as [bigint, string][] | undefined }, + /** + * Get the current value of the bool2 key in global state + */ + bool2: async (): Promise<[boolean, boolean][] | undefined> => { return (await this.appClient.state.global.getValue("bool2")) as [boolean, boolean][] | undefined }, + /** + * Get the current value of the bool7 key in global state + */ + bool7: async (): Promise<[bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] | undefined> => { return (await this.appClient.state.global.getValue("bool7")) as [bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] | undefined }, + /** + * Get the current value of the bool8 key in global state + */ + bool8: async (): Promise<[bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] | undefined> => { return (await this.appClient.state.global.getValue("bool8")) as [bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] | undefined }, + /** + * Get the current value of the bool9 key in global state + */ + bool9: async (): Promise<[bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] | undefined> => { return (await this.appClient.state.global.getValue("bool9")) as [bigint, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, bigint][] | undefined }, + /** + * Get the current value of the imm_fixed_arr key in global state + */ + immFixedArr: async (): Promise<[[bigint, bigint], [bigint, bigint], [bigint, bigint]] | undefined> => { return (await this.appClient.state.global.getValue("imm_fixed_arr")) as [[bigint, bigint], [bigint, bigint], [bigint, bigint]] | undefined }, + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): ImmutableArrayContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a test_uint64_array()void method call against the ImmutableArrayContract contract + */ + testUint64Array(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testUint64Array(params))) + return this + }, + /** + * Add a test_biguint_array()void method call against the ImmutableArrayContract contract + */ + testBiguintArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testBiguintArray(params))) + return this + }, + /** + * Add a test_bool_array(uint64)void method call against the ImmutableArrayContract contract + */ + testBoolArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testBoolArray(params))) + return this + }, + /** + * Add a test_fixed_size_tuple_array()void method call against the ImmutableArrayContract contract + */ + testFixedSizeTupleArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testFixedSizeTupleArray(params))) + return this + }, + /** + * Add a test_fixed_size_named_tuple_array()void method call against the ImmutableArrayContract contract + */ + testFixedSizeNamedTupleArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testFixedSizeNamedTupleArray(params))) + return this + }, + /** + * Add a test_dynamic_sized_tuple_array()void method call against the ImmutableArrayContract contract + */ + testDynamicSizedTupleArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testDynamicSizedTupleArray(params))) + return this + }, + /** + * Add a test_dynamic_sized_named_tuple_array()void method call against the ImmutableArrayContract contract + */ + testDynamicSizedNamedTupleArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testDynamicSizedNamedTupleArray(params))) + return this + }, + /** + * Add a test_implicit_conversion_log(uint64[])void method call against the ImmutableArrayContract contract + */ + testImplicitConversionLog(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testImplicitConversionLog(params))) + return this + }, + /** + * Add a test_implicit_conversion_emit(uint64[])void method call against the ImmutableArrayContract contract + */ + testImplicitConversionEmit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testImplicitConversionEmit(params))) + return this + }, + /** + * Add a test_nested_array(uint64,uint64[][])uint64[] method call against the ImmutableArrayContract contract + */ + testNestedArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testNestedArray(params))) + return this + }, + /** + * Add a test_bit_packed_tuples()void method call against the ImmutableArrayContract contract + */ + testBitPackedTuples(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testBitPackedTuples(params))) + return this + }, + /** + * Add a sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64) method call against the ImmutableArrayContract contract + */ + sumUintsAndLengthsAndTrues(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.sumUintsAndLengthsAndTrues(params))) + return this + }, + /** + * Add a test_uint64_return(uint64)uint64[] method call against the ImmutableArrayContract contract + */ + testUint64Return(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testUint64Return(params))) + return this + }, + /** + * Add a test_bool_return(uint64)bool[] method call against the ImmutableArrayContract contract + */ + testBoolReturn(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testBoolReturn(params))) + return this + }, + /** + * Add a test_tuple_return(uint64)(uint64,bool,bool)[] method call against the ImmutableArrayContract contract + */ + testTupleReturn(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testTupleReturn(params))) + return this + }, + /** + * Add a test_dynamic_tuple_return(uint64)(uint64,string)[] method call against the ImmutableArrayContract contract + */ + testDynamicTupleReturn(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testDynamicTupleReturn(params))) + return this + }, + /** + * Add a test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[] method call against the ImmutableArrayContract contract + */ + testConvertToArrayAndBack(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testConvertToArrayAndBack(params))) + return this + }, + /** + * Add a test_concat_with_arc4_tuple((uint64,uint64))uint64[] method call against the ImmutableArrayContract contract + */ + testConcatWithArc4Tuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testConcatWithArc4Tuple(params))) + return this + }, + /** + * Add a test_concat_with_native_tuple((uint64,uint64))uint64[] method call against the ImmutableArrayContract contract + */ + testConcatWithNativeTuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testConcatWithNativeTuple(params))) + return this + }, + /** + * Add a test_dynamic_concat_with_arc4_tuple((string,string))string[] method call against the ImmutableArrayContract contract + */ + testDynamicConcatWithArc4Tuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testDynamicConcatWithArc4Tuple(params))) + return this + }, + /** + * Add a test_dynamic_concat_with_native_tuple((string,string))string[] method call against the ImmutableArrayContract contract + */ + testDynamicConcatWithNativeTuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testDynamicConcatWithNativeTuple(params))) + return this + }, + /** + * Add a test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[] method call against the ImmutableArrayContract contract + */ + testConcatImmutableDynamic(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testConcatImmutableDynamic(params))) + return this + }, + /** + * Add a test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[] method call against the ImmutableArrayContract contract + */ + testImmutableArc4(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testImmutableArc4(params))) + return this + }, + /** + * Add a test_imm_fixed_arr()(uint64,uint64)[3] method call against the ImmutableArrayContract contract + */ + testImmFixedArr(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testImmFixedArr(params))) + return this + }, + /** + * Add a clear state call to the ImmutableArrayContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as ImmutableArrayContractComposer + } +} +export type ImmutableArrayContractComposer = { + /** + * Calls the test_uint64_array()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testUint64Array(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_uint64_array()void'] | undefined]> + + /** + * Calls the test_biguint_array()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testBiguintArray(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_biguint_array()void'] | undefined]> + + /** + * Calls the test_bool_array(uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testBoolArray(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_bool_array(uint64)void'] | undefined]> + + /** + * Calls the test_fixed_size_tuple_array()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testFixedSizeTupleArray(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_fixed_size_tuple_array()void'] | undefined]> + + /** + * Calls the test_fixed_size_named_tuple_array()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testFixedSizeNamedTupleArray(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_fixed_size_named_tuple_array()void'] | undefined]> + + /** + * Calls the test_dynamic_sized_tuple_array()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testDynamicSizedTupleArray(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_dynamic_sized_tuple_array()void'] | undefined]> + + /** + * Calls the test_dynamic_sized_named_tuple_array()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testDynamicSizedNamedTupleArray(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_dynamic_sized_named_tuple_array()void'] | undefined]> + + /** + * Calls the test_implicit_conversion_log(uint64[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testImplicitConversionLog(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_implicit_conversion_log(uint64[])void'] | undefined]> + + /** + * Calls the test_implicit_conversion_emit(uint64[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testImplicitConversionEmit(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_implicit_conversion_emit(uint64[])void'] | undefined]> + + /** + * Calls the test_nested_array(uint64,uint64[][])uint64[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testNestedArray(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_nested_array(uint64,uint64[][])uint64[]'] | undefined]> + + /** + * Calls the test_bit_packed_tuples()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testBitPackedTuples(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_bit_packed_tuples()void'] | undefined]> + + /** + * Calls the sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + sumUintsAndLengthsAndTrues(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)'] | undefined]> + + /** + * Calls the test_uint64_return(uint64)uint64[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testUint64Return(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_uint64_return(uint64)uint64[]'] | undefined]> + + /** + * Calls the test_bool_return(uint64)bool[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testBoolReturn(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_bool_return(uint64)bool[]'] | undefined]> + + /** + * Calls the test_tuple_return(uint64)(uint64,bool,bool)[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testTupleReturn(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_tuple_return(uint64)(uint64,bool,bool)[]'] | undefined]> + + /** + * Calls the test_dynamic_tuple_return(uint64)(uint64,string)[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testDynamicTupleReturn(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_dynamic_tuple_return(uint64)(uint64,string)[]'] | undefined]> + + /** + * Calls the test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testConvertToArrayAndBack(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]'] | undefined]> + + /** + * Calls the test_concat_with_arc4_tuple((uint64,uint64))uint64[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testConcatWithArc4Tuple(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_concat_with_arc4_tuple((uint64,uint64))uint64[]'] | undefined]> + + /** + * Calls the test_concat_with_native_tuple((uint64,uint64))uint64[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testConcatWithNativeTuple(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_concat_with_native_tuple((uint64,uint64))uint64[]'] | undefined]> + + /** + * Calls the test_dynamic_concat_with_arc4_tuple((string,string))string[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testDynamicConcatWithArc4Tuple(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_dynamic_concat_with_arc4_tuple((string,string))string[]'] | undefined]> + + /** + * Calls the test_dynamic_concat_with_native_tuple((string,string))string[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testDynamicConcatWithNativeTuple(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_dynamic_concat_with_native_tuple((string,string))string[]'] | undefined]> + + /** + * Calls the test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testConcatImmutableDynamic(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]'] | undefined]> + + /** + * Calls the test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testImmutableArc4(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]'] | undefined]> + + /** + * Calls the test_imm_fixed_arr()(uint64,uint64)[3] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testImmFixedArr(params?: CallParams): ImmutableArrayContractComposer<[...TReturns, ImmutableArrayContractReturns['test_imm_fixed_arr()(uint64,uint64)[3]'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the ImmutableArrayContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): ImmutableArrayContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): ImmutableArrayContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type ImmutableArrayContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/ImmutableArrayInitContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/ImmutableArrayInitContract.ts new file mode 100644 index 0000000..358fea4 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/ImmutableArrayInitContract.ts @@ -0,0 +1,755 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"ImmutableArrayInitContract","structs":{},"methods":[{"name":"test_immutable_array_init","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_immutable_array_init_without_type_generic","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_reference_array_init","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_reference_array_init_without_type_generic","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[42],"errorMessage":"OnCompletion must be NoOp"},{"pc":[89],"errorMessage":"OnCompletion must be NoOp && can only call when creating"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 8 3 1 0
    bytecblock 0x000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/immutable.py:479
    // class ImmutableArrayInitContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@11
    txn OnCompletion
    !
    assert // OnCompletion must be NoOp
    txn ApplicationID
    assert
    pushbytess 0x8434ba2a 0x63aabba0 0xdbaf034e 0xa9d14554 // method "test_immutable_array_init()void", method "test_immutable_array_init_without_type_generic()void", method "test_reference_array_init()void", method "test_reference_array_init_without_type_generic()void"
    txna ApplicationArgs 0
    match test_immutable_array_init test_immutable_array_init_without_type_generic test_reference_array_init test_reference_array_init_without_type_generic
    err

main___algopy_default_create@11:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return // on error: OnCompletion must be NoOp && can only call when creating


// tests.artifacts.Arrays.immutable.ImmutableArrayInitContract.test_immutable_array_init[routing]() -> void:
test_immutable_array_init:
    // tests/artifacts/Arrays/immutable.py:490
    // a3 = ImmutableArray[UInt64](ReferenceArray((UInt64(1), UInt64(2), UInt64(3))))
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    pop
    // tests/artifacts/Arrays/immutable.py:480
    // @arc4.abimethod()
    intc_2 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayInitContract.test_immutable_array_init_without_type_generic[routing]() -> void:
test_immutable_array_init_without_type_generic:
    // tests/artifacts/Arrays/immutable.py:512
    // a3 = ImmutableArray(ReferenceArray((UInt64(1), UInt64(2), UInt64(3))))
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    pop
    // tests/artifacts/Arrays/immutable.py:502
    // @arc4.abimethod()
    intc_2 // 1
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayInitContract.test_reference_array_init[routing]() -> void:
test_reference_array_init:
    // tests/artifacts/Arrays/immutable.py:526
    // a1 = ReferenceArray[UInt64]((UInt64(1), UInt64(2), UInt64(3)))
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/immutable.py:528
    // a2 = ReferenceArray[UInt64](FixedArray((UInt64(1), UInt64(2), UInt64(3))))
    dup
    pop
    dupn 2
    // tests/artifacts/Arrays/immutable.py:529
    // assert a1.length == a2.length
    len
    intc_0 // 8
    /
    intc_1 // 3
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:530
    // assert a1[0] == a2[0]
    dup
    intc_3 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:531
    // assert a1[1] == a2[1]
    dup
    intc_0 // 8
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:532
    // assert a1[2] == a2[2]
    pushint 16 // 16
    extract_uint64
    intc_1 // 3
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:534
    // a3 = ReferenceArray[UInt64](ImmutableArray((UInt64(1), UInt64(2), UInt64(3))))
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    pop
    dupn 2
    // tests/artifacts/Arrays/immutable.py:536
    // assert a1[0] == a3[0]
    intc_3 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:537
    // assert a1[1] == a3[1]
    dup
    intc_0 // 8
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:538
    // assert a1[2] == a3[2]
    pushint 16 // 16
    extract_uint64
    intc_1 // 3
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:526
    // a1 = ReferenceArray[UInt64]((UInt64(1), UInt64(2), UInt64(3)))
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    pop
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    pop
    // tests/artifacts/Arrays/immutable.py:541
    // assert a1.length == a4.length
    dup
    len
    intc_0 // 8
    /
    intc_1 // 3
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:542
    // assert a1[0] == a4[0]
    dup
    intc_3 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:543
    // assert a1[1] == a4[1]
    dup
    intc_0 // 8
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:544
    // assert a1[2] == a4[2]
    pushint 16 // 16
    extract_uint64
    intc_1 // 3
    ==
    // tests/artifacts/Arrays/immutable.py:524
    // @arc4.abimethod()
    return


// tests.artifacts.Arrays.immutable.ImmutableArrayInitContract.test_reference_array_init_without_type_generic[routing]() -> void:
test_reference_array_init_without_type_generic:
    // tests/artifacts/Arrays/immutable.py:548
    // a1 = ReferenceArray((UInt64(1), UInt64(2), UInt64(3)))
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/immutable.py:550
    // a2 = ReferenceArray(FixedArray((UInt64(1), UInt64(2), UInt64(3))))
    dup
    pop
    dupn 2
    // tests/artifacts/Arrays/immutable.py:551
    // assert a1.length == a2.length
    len
    intc_0 // 8
    /
    intc_1 // 3
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:552
    // assert a1[0] == a2[0]
    dup
    intc_3 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:553
    // assert a1[1] == a2[1]
    dup
    intc_0 // 8
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:554
    // assert a1[2] == a2[2]
    pushint 16 // 16
    extract_uint64
    intc_1 // 3
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:556
    // a3 = ReferenceArray(ImmutableArray((UInt64(1), UInt64(2), UInt64(3))))
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    pop
    dupn 2
    // tests/artifacts/Arrays/immutable.py:558
    // assert a1[0] == a3[0]
    intc_3 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:559
    // assert a1[1] == a3[1]
    dup
    intc_0 // 8
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:560
    // assert a1[2] == a3[2]
    pushint 16 // 16
    extract_uint64
    intc_1 // 3
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:548
    // a1 = ReferenceArray((UInt64(1), UInt64(2), UInt64(3)))
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    pop
    bytec_0 // 0x000000000000000100000000000000020000000000000003
    pop
    // tests/artifacts/Arrays/immutable.py:563
    // assert a1.length == a4.length
    dup
    len
    intc_0 // 8
    /
    intc_1 // 3
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:564
    // assert a1[0] == a4[0]
    dup
    intc_3 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:565
    // assert a1[1] == a4[1]
    dup
    intc_0 // 8
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:566
    // assert a1[2] == a4[2]
    pushint 16 // 16
    extract_uint64
    intc_1 // 3
    ==
    // tests/artifacts/Arrays/immutable.py:546
    // @arc4.abimethod()
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"},"byteCode":{"approval":"CiAECAMBACYBGAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAzEbQQArMRkURDEYRIIEBIQ0uioEY6q7oATbrwNOBKnRRVQ2GgCOBAAJAA0AEQBjADEZFDEYFBBDKEgkQyhIJEMoSUhHAhUiCiMSREklWyQSREkiW4ECEkSBEFsjEkQoSEcCJVskEkRJIluBAhJEgRBbIxJEKEgoSEkVIgojEkRJJVskEkRJIluBAhJEgRBbIxJDKElIRwIVIgojEkRJJVskEkRJIluBAhJEgRBbIxJEKEhHAiVbJBJESSJbgQISRIEQWyMSRChIKEhJFSIKIxJESSVbJBJESSJbgQISRIEQWyMSQw==","clear":"CoEBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the ImmutableArrayInitContract contract + */ +export type ImmutableArrayInitContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'test_immutable_array_init()void': Record + 'test_immutable_array_init_without_type_generic()void': Record + 'test_reference_array_init()void': Record + 'test_reference_array_init_without_type_generic()void': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'test_immutable_array_init()void': [] + 'test_immutable_array_init_without_type_generic()void': [] + 'test_reference_array_init()void': [] + 'test_reference_array_init_without_type_generic()void': [] + } +} + +/** + * The return type for each method + */ +export type ImmutableArrayInitContractReturns = { + 'test_immutable_array_init()void': void + 'test_immutable_array_init_without_type_generic()void': void + 'test_reference_array_init()void': void + 'test_reference_array_init_without_type_generic()void': void +} + +/** + * Defines the types of available calls and state of the ImmutableArrayInitContract smart contract. + */ +export type ImmutableArrayInitContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'test_immutable_array_init()void' | 'test_immutable_array_init', { + argsObj: ImmutableArrayInitContractArgs['obj']['test_immutable_array_init()void'] + argsTuple: ImmutableArrayInitContractArgs['tuple']['test_immutable_array_init()void'] + returns: ImmutableArrayInitContractReturns['test_immutable_array_init()void'] + }> + & Record<'test_immutable_array_init_without_type_generic()void' | 'test_immutable_array_init_without_type_generic', { + argsObj: ImmutableArrayInitContractArgs['obj']['test_immutable_array_init_without_type_generic()void'] + argsTuple: ImmutableArrayInitContractArgs['tuple']['test_immutable_array_init_without_type_generic()void'] + returns: ImmutableArrayInitContractReturns['test_immutable_array_init_without_type_generic()void'] + }> + & Record<'test_reference_array_init()void' | 'test_reference_array_init', { + argsObj: ImmutableArrayInitContractArgs['obj']['test_reference_array_init()void'] + argsTuple: ImmutableArrayInitContractArgs['tuple']['test_reference_array_init()void'] + returns: ImmutableArrayInitContractReturns['test_reference_array_init()void'] + }> + & Record<'test_reference_array_init_without_type_generic()void' | 'test_reference_array_init_without_type_generic', { + argsObj: ImmutableArrayInitContractArgs['obj']['test_reference_array_init_without_type_generic()void'] + argsTuple: ImmutableArrayInitContractArgs['tuple']['test_reference_array_init_without_type_generic()void'] + returns: ImmutableArrayInitContractReturns['test_reference_array_init_without_type_generic()void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type ImmutableArrayInitContractSignatures = keyof ImmutableArrayInitContractTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the ImmutableArrayInitContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = ImmutableArrayInitContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the ImmutableArrayInitContract smart contract to the method's return type + */ +export type MethodReturn = ImmutableArrayInitContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type ImmutableArrayInitContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type ImmutableArrayInitContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: ImmutableArrayInitContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the ImmutableArrayInitContract smart contract + */ +export abstract class ImmutableArrayInitContractParamsFactory { + /** + * Constructs a no op call for the test_immutable_array_init()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testImmutableArrayInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_immutable_array_init()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_immutable_array_init_without_type_generic()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testImmutableArrayInitWithoutTypeGeneric(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_immutable_array_init_without_type_generic()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_reference_array_init()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testReferenceArrayInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_reference_array_init()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the test_reference_array_init_without_type_generic()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testReferenceArrayInitWithoutTypeGeneric(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_reference_array_init_without_type_generic()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the ImmutableArrayInitContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class ImmutableArrayInitContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `ImmutableArrayInitContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new ImmutableArrayInitContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new ImmutableArrayInitContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the ImmutableArrayInitContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: ImmutableArrayInitContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new ImmutableArrayInitContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ImmutableArrayInitContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ImmutableArrayInitContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the ImmutableArrayInitContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new ImmutableArrayInitContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the ImmutableArrayInitContract smart contract + */ +export class ImmutableArrayInitContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `ImmutableArrayInitContractClient` + * + * @param appClient An `AppClient` instance which has been created with the ImmutableArrayInitContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `ImmutableArrayInitContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `ImmutableArrayInitContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new ImmutableArrayInitContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `ImmutableArrayInitContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new ImmutableArrayInitContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the ImmutableArrayInitContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_immutable_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testImmutableArrayInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayInitContractParamsFactory.testImmutableArrayInit(params)) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_immutable_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testImmutableArrayInitWithoutTypeGeneric: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayInitContractParamsFactory.testImmutableArrayInitWithoutTypeGeneric(params)) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_reference_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testReferenceArrayInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayInitContractParamsFactory.testReferenceArrayInit(params)) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_reference_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testReferenceArrayInitWithoutTypeGeneric: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(ImmutableArrayInitContractParamsFactory.testReferenceArrayInitWithoutTypeGeneric(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the ImmutableArrayInitContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_immutable_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testImmutableArrayInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayInitContractParamsFactory.testImmutableArrayInit(params)) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_immutable_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testImmutableArrayInitWithoutTypeGeneric: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayInitContractParamsFactory.testImmutableArrayInitWithoutTypeGeneric(params)) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_reference_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testReferenceArrayInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayInitContractParamsFactory.testReferenceArrayInit(params)) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_reference_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testReferenceArrayInitWithoutTypeGeneric: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(ImmutableArrayInitContractParamsFactory.testReferenceArrayInitWithoutTypeGeneric(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the ImmutableArrayInitContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_immutable_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testImmutableArrayInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayInitContractParamsFactory.testImmutableArrayInit(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayInitContractReturns['test_immutable_array_init()void'])} + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_immutable_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testImmutableArrayInitWithoutTypeGeneric: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayInitContractParamsFactory.testImmutableArrayInitWithoutTypeGeneric(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayInitContractReturns['test_immutable_array_init_without_type_generic()void'])} + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_reference_array_init()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testReferenceArrayInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayInitContractParamsFactory.testReferenceArrayInit(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayInitContractReturns['test_reference_array_init()void'])} + }, + + /** + * Makes a call to the ImmutableArrayInitContract smart contract using the `test_reference_array_init_without_type_generic()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testReferenceArrayInitWithoutTypeGeneric: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(ImmutableArrayInitContractParamsFactory.testReferenceArrayInitWithoutTypeGeneric(params)) + return {...result, return: result.return as unknown as (undefined | ImmutableArrayInitContractReturns['test_reference_array_init_without_type_generic()void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new ImmutableArrayInitContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current ImmutableArrayInitContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): ImmutableArrayInitContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a test_immutable_array_init()void method call against the ImmutableArrayInitContract contract + */ + testImmutableArrayInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testImmutableArrayInit(params))) + return this + }, + /** + * Add a test_immutable_array_init_without_type_generic()void method call against the ImmutableArrayInitContract contract + */ + testImmutableArrayInitWithoutTypeGeneric(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testImmutableArrayInitWithoutTypeGeneric(params))) + return this + }, + /** + * Add a test_reference_array_init()void method call against the ImmutableArrayInitContract contract + */ + testReferenceArrayInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testReferenceArrayInit(params))) + return this + }, + /** + * Add a test_reference_array_init_without_type_generic()void method call against the ImmutableArrayInitContract contract + */ + testReferenceArrayInitWithoutTypeGeneric(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testReferenceArrayInitWithoutTypeGeneric(params))) + return this + }, + /** + * Add a clear state call to the ImmutableArrayInitContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as ImmutableArrayInitContractComposer + } +} +export type ImmutableArrayInitContractComposer = { + /** + * Calls the test_immutable_array_init()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testImmutableArrayInit(params?: CallParams): ImmutableArrayInitContractComposer<[...TReturns, ImmutableArrayInitContractReturns['test_immutable_array_init()void'] | undefined]> + + /** + * Calls the test_immutable_array_init_without_type_generic()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testImmutableArrayInitWithoutTypeGeneric(params?: CallParams): ImmutableArrayInitContractComposer<[...TReturns, ImmutableArrayInitContractReturns['test_immutable_array_init_without_type_generic()void'] | undefined]> + + /** + * Calls the test_reference_array_init()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testReferenceArrayInit(params?: CallParams): ImmutableArrayInitContractComposer<[...TReturns, ImmutableArrayInitContractReturns['test_reference_array_init()void'] | undefined]> + + /** + * Calls the test_reference_array_init_without_type_generic()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testReferenceArrayInitWithoutTypeGeneric(params?: CallParams): ImmutableArrayInitContractComposer<[...TReturns, ImmutableArrayInitContractReturns['test_reference_array_init_without_type_generic()void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the ImmutableArrayInitContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): ImmutableArrayInitContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): ImmutableArrayInitContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type ImmutableArrayInitContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/LocalStateContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/LocalStateContract.ts new file mode 100644 index 0000000..767e777 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/LocalStateContract.ts @@ -0,0 +1,1746 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"LocalStateContract","structs":{},"methods":[{"name":"opt_in","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["OptIn"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_uint","args":[{"type":"address","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_string","args":[{"type":"address","name":"a"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_byte","args":[{"type":"address","name":"a"}],"returns":{"type":"byte"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_bool","args":[{"type":"address","name":"a"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_address","args":[{"type":"address","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_uint128","args":[{"type":"address","name":"a"}],"returns":{"type":"uint128"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_arc4_dynamic_bytes","args":[{"type":"address","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_implicit_key_tuple","args":[{"type":"address","name":"a"}],"returns":{"type":"(uint64,byte[],bool)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_uint","args":[{"type":"address","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_string","args":[{"type":"address","name":"a"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_byte","args":[{"type":"address","name":"a"}],"returns":{"type":"byte"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_bool","args":[{"type":"address","name":"a"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_address","args":[{"type":"address","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_uint128","args":[{"type":"address","name":"a"}],"returns":{"type":"uint128"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get_arc4_dynamic_bytes","args":[{"type":"address","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":15}},"keys":{"global":{},"local":{"implicit_key_arc4_uint":{"keyType":"AVMString","valueType":"uint64","key":"aW1wbGljaXRfa2V5X2FyYzRfdWludA=="},"implicit_key_arc4_string":{"keyType":"AVMString","valueType":"string","key":"aW1wbGljaXRfa2V5X2FyYzRfc3RyaW5n"},"implicit_key_arc4_byte":{"keyType":"AVMString","valueType":"byte","key":"aW1wbGljaXRfa2V5X2FyYzRfYnl0ZQ=="},"implicit_key_arc4_bool":{"keyType":"AVMString","valueType":"bool","key":"aW1wbGljaXRfa2V5X2FyYzRfYm9vbA=="},"implicit_key_arc4_address":{"keyType":"AVMString","valueType":"address","key":"aW1wbGljaXRfa2V5X2FyYzRfYWRkcmVzcw=="},"implicit_key_arc4_uint128":{"keyType":"AVMString","valueType":"uint128","key":"aW1wbGljaXRfa2V5X2FyYzRfdWludDEyOA=="},"implicit_key_arc4_dynamic_bytes":{"keyType":"AVMString","valueType":"byte[]","key":"aW1wbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlcw=="},"implicit_key_tuple":{"keyType":"AVMString","valueType":"(uint64,byte[],bool)","key":"aW1wbGljaXRfa2V5X3R1cGxl"},"arc4_uint":{"keyType":"AVMString","valueType":"uint64","key":"ZXhwbGljaXRfa2V5X2FyYzRfdWludA=="},"arc4_string":{"keyType":"AVMString","valueType":"string","key":"ZXhwbGljaXRfa2V5X2FyYzRfc3RyaW5n"},"arc4_byte":{"keyType":"AVMString","valueType":"byte","key":"ZXhwbGljaXRfa2V5X2FyYzRfYnl0ZQ=="},"arc4_bool":{"keyType":"AVMString","valueType":"bool","key":"ZXhwbGljaXRfa2V5X2FyYzRfYm9vbA=="},"arc4_address":{"keyType":"AVMString","valueType":"address","key":"ZXhwbGljaXRfa2V5X2FyYzRfYWRkcmVzcw=="},"arc4_uint128":{"keyType":"AVMString","valueType":"uint128","key":"ZXhwbGljaXRfa2V5X2FyYzRfdWludDEyOA=="},"arc4_dynamic_bytes":{"keyType":"AVMString","valueType":"byte[]","key":"ZXhwbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlcw=="}},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[891],"errorMessage":"check self.arc4_address exists for account"},{"pc":[877],"errorMessage":"check self.arc4_bool exists for account"},{"pc":[863],"errorMessage":"check self.arc4_byte exists for account"},{"pc":[919],"errorMessage":"check self.arc4_dynamic_bytes exists for account"},{"pc":[849],"errorMessage":"check self.arc4_string exists for account"},{"pc":[835],"errorMessage":"check self.arc4_uint exists for account"},{"pc":[905],"errorMessage":"check self.arc4_uint128 exists for account"},{"pc":[779],"errorMessage":"check self.implicit_key_arc4_address exists for account"},{"pc":[765],"errorMessage":"check self.implicit_key_arc4_bool exists for account"},{"pc":[751],"errorMessage":"check self.implicit_key_arc4_byte exists for account"},{"pc":[807],"errorMessage":"check self.implicit_key_arc4_dynamic_bytes exists for account"},{"pc":[737],"errorMessage":"check self.implicit_key_arc4_string exists for account"},{"pc":[724],"errorMessage":"check self.implicit_key_arc4_uint exists for account"},{"pc":[793],"errorMessage":"check self.implicit_key_arc4_uint128 exists for account"},{"pc":[821],"errorMessage":"check self.implicit_key_tuple exists for account"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75 "implicit_key_arc4_uint" 0x0000000000000539 "implicit_key_arc4_string" 0x000548656c6c6f "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" 0x00000010000000000000000000000000 "implicit_key_arc4_dynamic_bytes" 0x000d64796e616d6963206279746573 "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@26
    pushbytes 0x30c6d58a // method "opt_in()void"
    txna ApplicationArgs 0
    match main_opt_in_route@5

main_switch_case_next@6:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0xb3cfa389 0xdb858176 0x78267762 0x426351c8 0x075cae91 0x59c0b80b 0x0d6fa690 0x97e10d9c 0x2e4a8c49 0xb22cd21e 0xb3f44701 0xedd97297 0x671d353c 0xa3fd6fdc 0xcd2e5d66 // method "get_implicit_key_arc4_uint(address)uint64", method "get_implicit_key_arc4_string(address)string", method "get_implicit_key_arc4_byte(address)byte", method "get_implicit_key_arc4_bool(address)bool", method "get_implicit_key_arc4_address(address)address", method "get_implicit_key_arc4_uint128(address)uint128", method "get_implicit_key_arc4_dynamic_bytes(address)byte[]", method "get_implicit_key_tuple(address)(uint64,byte[],bool)", method "get_arc4_uint(address)uint64", method "get_arc4_string(address)string", method "get_arc4_byte(address)byte", method "get_arc4_bool(address)bool", method "get_arc4_address(address)address", method "get_arc4_uint128(address)uint128", method "get_arc4_dynamic_bytes(address)byte[]"
    txna ApplicationArgs 0
    match get_implicit_key_arc4_uint get_implicit_key_arc4_string get_implicit_key_arc4_byte get_implicit_key_arc4_bool get_implicit_key_arc4_address get_implicit_key_arc4_uint128 get_implicit_key_arc4_dynamic_bytes get_implicit_key_tuple get_arc4_uint get_arc4_string get_arc4_byte get_arc4_bool get_arc4_address get_arc4_uint128 get_arc4_dynamic_bytes
    err

main_opt_in_route@5:
    // tests/artifacts/StateOps/contract.py:686
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    intc_0 // OptIn
    ==
    txn ApplicationID
    &&
    assert
    b opt_in

main___algopy_default_create@26:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.StateOps.contract.LocalStateContract.opt_in[routing]() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:688
    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec_1 // "implicit_key_arc4_uint"
    bytec_2 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:689
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec_3 // "implicit_key_arc4_string"
    bytec 4 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:690
    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 5 // "implicit_key_arc4_byte"
    pushbytes 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:691
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 6 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:692
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    global CreatorAddress
    bytec 7 // "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:693
    // Global.creator_address
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:692-694
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    //     Global.creator_address
    // )
    app_local_put
    // tests/artifacts/StateOps/contract.py:695
    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 8 // "implicit_key_arc4_uint128"
    bytec 9 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:696
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    global CreatorAddress
    bytec 10 // "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:696-698
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 11 // 0x000d64796e616d6963206279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:699
    // self.implicit_key_tuple[Global.creator_address] = (UInt64(10), Bytes(b"test"), False)
    global CreatorAddress
    bytec 12 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_local_put
    // tests/artifacts/StateOps/contract.py:701
    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec 13 // "explicit_key_arc4_uint"
    bytec_2 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:702
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 14 // "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:689
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    bytec 4 // 0x000548656c6c6f
    // tests/artifacts/StateOps/contract.py:702
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    app_local_put
    // tests/artifacts/StateOps/contract.py:703
    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 15 // "explicit_key_arc4_byte"
    pushbytes 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:704
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 16 // "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:691
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    pushbytes 0x80
    // tests/artifacts/StateOps/contract.py:704
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    app_local_put
    // tests/artifacts/StateOps/contract.py:705
    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
    global CreatorAddress
    bytec 17 // "explicit_key_arc4_address"
    global CreatorAddress
    app_local_put
    // tests/artifacts/StateOps/contract.py:706
    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 18 // "explicit_key_arc4_uint128"
    bytec 9 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:707
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    global CreatorAddress
    bytec 19 // "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:696-698
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 11 // 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:707
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    app_local_put
    // tests/artifacts/StateOps/contract.py:686
    // @arc4.abimethod(allow_actions=["OptIn"])
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint[routing]() -> void:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:712
    // return self.implicit_key_arc4_uint[a]
    intc_1 // 0
    bytec_1 // "implicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint exists for account
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_string[routing]() -> void:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:716
    // return self.implicit_key_arc4_string[a]
    intc_1 // 0
    bytec_3 // "implicit_key_arc4_string"
    app_local_get_ex
    assert // check self.implicit_key_arc4_string exists for account
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_byte[routing]() -> void:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:720
    // return self.implicit_key_arc4_byte[a]
    intc_1 // 0
    bytec 5 // "implicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.implicit_key_arc4_byte exists for account
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_bool[routing]() -> void:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:724
    // return self.implicit_key_arc4_bool[a]
    intc_1 // 0
    bytec 6 // "implicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.implicit_key_arc4_bool exists for account
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_address[routing]() -> void:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:728
    // return self.implicit_key_arc4_address[a]
    intc_1 // 0
    bytec 7 // "implicit_key_arc4_address"
    app_local_get_ex
    assert // check self.implicit_key_arc4_address exists for account
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint128[routing]() -> void:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:732
    // return self.implicit_key_arc4_uint128[a]
    intc_1 // 0
    bytec 8 // "implicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint128 exists for account
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_dynamic_bytes[routing]() -> void:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:736
    // return self.implicit_key_arc4_dynamic_bytes[a]
    intc_1 // 0
    bytec 10 // "implicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists for account
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_tuple[routing]() -> void:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:740
    // return self.implicit_key_tuple[a]
    intc_1 // 0
    bytec 12 // "implicit_key_tuple"
    app_local_get_ex
    assert // check self.implicit_key_tuple exists for account
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint[routing]() -> void:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:745
    // return self.arc4_uint[a]
    intc_1 // 0
    bytec 13 // "explicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.arc4_uint exists for account
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_string[routing]() -> void:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:749
    // return self.arc4_string[a]
    intc_1 // 0
    bytec 14 // "explicit_key_arc4_string"
    app_local_get_ex
    assert // check self.arc4_string exists for account
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_byte[routing]() -> void:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:753
    // return self.arc4_byte[a]
    intc_1 // 0
    bytec 15 // "explicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.arc4_byte exists for account
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_bool[routing]() -> void:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:757
    // return self.arc4_bool[a]
    intc_1 // 0
    bytec 16 // "explicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.arc4_bool exists for account
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_address[routing]() -> void:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:761
    // return self.arc4_address[a]
    intc_1 // 0
    bytec 17 // "explicit_key_arc4_address"
    app_local_get_ex
    assert // check self.arc4_address exists for account
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint128[routing]() -> void:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:765
    // return self.arc4_uint128[a]
    intc_1 // 0
    bytec 18 // "explicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.arc4_uint128 exists for account
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_dynamic_bytes[routing]() -> void:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:769
    // return self.arc4_dynamic_bytes[a]
    intc_1 // 0
    bytec 19 // "explicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.arc4_dynamic_bytes exists for account
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyACAQAmFAQVH3x1FmltcGxpY2l0X2tleV9hcmM0X3VpbnQIAAAAAAAABTkYaW1wbGljaXRfa2V5X2FyYzRfc3RyaW5nBwAFSGVsbG8WaW1wbGljaXRfa2V5X2FyYzRfYnl0ZRZpbXBsaWNpdF9rZXlfYXJjNF9ib29sGWltcGxpY2l0X2tleV9hcmM0X2FkZHJlc3MZaW1wbGljaXRfa2V5X2FyYzRfdWludDEyOBAAAAAQAAAAAAAAAAAAAAAAH2ltcGxpY2l0X2tleV9hcmM0X2R5bmFtaWNfYnl0ZXMPAA1keW5hbWljIGJ5dGVzEmltcGxpY2l0X2tleV90dXBsZRZleHBsaWNpdF9rZXlfYXJjNF91aW50GGV4cGxpY2l0X2tleV9hcmM0X3N0cmluZxZleHBsaWNpdF9rZXlfYXJjNF9ieXRlFmV4cGxpY2l0X2tleV9hcmM0X2Jvb2wZZXhwbGljaXRfa2V5X2FyYzRfYWRkcmVzcxlleHBsaWNpdF9rZXlfYXJjNF91aW50MTI4H2V4cGxpY2l0X2tleV9hcmM0X2R5bmFtaWNfYnl0ZXMxG0EAkIAEMMbVijYaAI4BAHgxGRREMRhEgg8Es8+jiQTbhYF2BHgmd2IEQmNRyAQHXK6RBFnAuAsEDW+mkASX4Q2cBC5KjEkEsizSHgSz9EcBBO3ZcpcEZx01PASj/W/cBM0uXWY2GgCODwCQAJ0AqgC4AMYA1ADiAPAA/gEMARoBKAE2AUQBUgAxGSISMRgQREIACDEZFDEYFBBDMgkpKmYyCSsnBGYyCScFgAEAZjIJJwaAAYBmMgknBzIJZjIJJwgnCWYyCScKJwtmMgknDIARAAAAAAAAAAoACwAABHRlc3RmMgknDSpmMgknDicEZjIJJw+AAQBmMgknEIABgGYyCScRMglmMgknEicJZjIJJxMnC2YiQzYaASMpY0QoTFCwIkM2GgEjK2NEKExQsCJDNhoBIycFY0QoTFCwIkM2GgEjJwZjRChMULAiQzYaASMnB2NEKExQsCJDNhoBIycIY0QoTFCwIkM2GgEjJwpjRChMULAiQzYaASMnDGNEKExQsCJDNhoBIycNY0QoTFCwIkM2GgEjJw5jRChMULAiQzYaASMnD2NEKExQsCJDNhoBIycQY0QoTFCwIkM2GgEjJxFjRChMULAiQzYaASMnEmNEKExQsCJDNhoBIycTY0QoTFCwIkM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the LocalStateContract contract + */ +export type LocalStateContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'opt_in()void': Record + 'get_implicit_key_arc4_uint(address)uint64': { + a: string + } + 'get_implicit_key_arc4_string(address)string': { + a: string + } + 'get_implicit_key_arc4_byte(address)byte': { + a: string + } + 'get_implicit_key_arc4_bool(address)bool': { + a: string + } + 'get_implicit_key_arc4_address(address)address': { + a: string + } + 'get_implicit_key_arc4_uint128(address)uint128': { + a: string + } + 'get_implicit_key_arc4_dynamic_bytes(address)byte[]': { + a: string + } + 'get_implicit_key_tuple(address)(uint64,byte[],bool)': { + a: string + } + 'get_arc4_uint(address)uint64': { + a: string + } + 'get_arc4_string(address)string': { + a: string + } + 'get_arc4_byte(address)byte': { + a: string + } + 'get_arc4_bool(address)bool': { + a: string + } + 'get_arc4_address(address)address': { + a: string + } + 'get_arc4_uint128(address)uint128': { + a: string + } + 'get_arc4_dynamic_bytes(address)byte[]': { + a: string + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'opt_in()void': [] + 'get_implicit_key_arc4_uint(address)uint64': [a: string] + 'get_implicit_key_arc4_string(address)string': [a: string] + 'get_implicit_key_arc4_byte(address)byte': [a: string] + 'get_implicit_key_arc4_bool(address)bool': [a: string] + 'get_implicit_key_arc4_address(address)address': [a: string] + 'get_implicit_key_arc4_uint128(address)uint128': [a: string] + 'get_implicit_key_arc4_dynamic_bytes(address)byte[]': [a: string] + 'get_implicit_key_tuple(address)(uint64,byte[],bool)': [a: string] + 'get_arc4_uint(address)uint64': [a: string] + 'get_arc4_string(address)string': [a: string] + 'get_arc4_byte(address)byte': [a: string] + 'get_arc4_bool(address)bool': [a: string] + 'get_arc4_address(address)address': [a: string] + 'get_arc4_uint128(address)uint128': [a: string] + 'get_arc4_dynamic_bytes(address)byte[]': [a: string] + } +} + +/** + * The return type for each method + */ +export type LocalStateContractReturns = { + 'opt_in()void': void + 'get_implicit_key_arc4_uint(address)uint64': bigint + 'get_implicit_key_arc4_string(address)string': string + 'get_implicit_key_arc4_byte(address)byte': number + 'get_implicit_key_arc4_bool(address)bool': boolean + 'get_implicit_key_arc4_address(address)address': string + 'get_implicit_key_arc4_uint128(address)uint128': bigint + 'get_implicit_key_arc4_dynamic_bytes(address)byte[]': Uint8Array + 'get_implicit_key_tuple(address)(uint64,byte[],bool)': [bigint, Uint8Array, boolean] + 'get_arc4_uint(address)uint64': bigint + 'get_arc4_string(address)string': string + 'get_arc4_byte(address)byte': number + 'get_arc4_bool(address)bool': boolean + 'get_arc4_address(address)address': string + 'get_arc4_uint128(address)uint128': bigint + 'get_arc4_dynamic_bytes(address)byte[]': Uint8Array +} + +/** + * Defines the types of available calls and state of the LocalStateContract smart contract. + */ +export type LocalStateContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'opt_in()void' | 'opt_in', { + argsObj: LocalStateContractArgs['obj']['opt_in()void'] + argsTuple: LocalStateContractArgs['tuple']['opt_in()void'] + returns: LocalStateContractReturns['opt_in()void'] + }> + & Record<'get_implicit_key_arc4_uint(address)uint64' | 'get_implicit_key_arc4_uint', { + argsObj: LocalStateContractArgs['obj']['get_implicit_key_arc4_uint(address)uint64'] + argsTuple: LocalStateContractArgs['tuple']['get_implicit_key_arc4_uint(address)uint64'] + returns: LocalStateContractReturns['get_implicit_key_arc4_uint(address)uint64'] + }> + & Record<'get_implicit_key_arc4_string(address)string' | 'get_implicit_key_arc4_string', { + argsObj: LocalStateContractArgs['obj']['get_implicit_key_arc4_string(address)string'] + argsTuple: LocalStateContractArgs['tuple']['get_implicit_key_arc4_string(address)string'] + returns: LocalStateContractReturns['get_implicit_key_arc4_string(address)string'] + }> + & Record<'get_implicit_key_arc4_byte(address)byte' | 'get_implicit_key_arc4_byte', { + argsObj: LocalStateContractArgs['obj']['get_implicit_key_arc4_byte(address)byte'] + argsTuple: LocalStateContractArgs['tuple']['get_implicit_key_arc4_byte(address)byte'] + returns: LocalStateContractReturns['get_implicit_key_arc4_byte(address)byte'] + }> + & Record<'get_implicit_key_arc4_bool(address)bool' | 'get_implicit_key_arc4_bool', { + argsObj: LocalStateContractArgs['obj']['get_implicit_key_arc4_bool(address)bool'] + argsTuple: LocalStateContractArgs['tuple']['get_implicit_key_arc4_bool(address)bool'] + returns: LocalStateContractReturns['get_implicit_key_arc4_bool(address)bool'] + }> + & Record<'get_implicit_key_arc4_address(address)address' | 'get_implicit_key_arc4_address', { + argsObj: LocalStateContractArgs['obj']['get_implicit_key_arc4_address(address)address'] + argsTuple: LocalStateContractArgs['tuple']['get_implicit_key_arc4_address(address)address'] + returns: LocalStateContractReturns['get_implicit_key_arc4_address(address)address'] + }> + & Record<'get_implicit_key_arc4_uint128(address)uint128' | 'get_implicit_key_arc4_uint128', { + argsObj: LocalStateContractArgs['obj']['get_implicit_key_arc4_uint128(address)uint128'] + argsTuple: LocalStateContractArgs['tuple']['get_implicit_key_arc4_uint128(address)uint128'] + returns: LocalStateContractReturns['get_implicit_key_arc4_uint128(address)uint128'] + }> + & Record<'get_implicit_key_arc4_dynamic_bytes(address)byte[]' | 'get_implicit_key_arc4_dynamic_bytes', { + argsObj: LocalStateContractArgs['obj']['get_implicit_key_arc4_dynamic_bytes(address)byte[]'] + argsTuple: LocalStateContractArgs['tuple']['get_implicit_key_arc4_dynamic_bytes(address)byte[]'] + returns: LocalStateContractReturns['get_implicit_key_arc4_dynamic_bytes(address)byte[]'] + }> + & Record<'get_implicit_key_tuple(address)(uint64,byte[],bool)' | 'get_implicit_key_tuple', { + argsObj: LocalStateContractArgs['obj']['get_implicit_key_tuple(address)(uint64,byte[],bool)'] + argsTuple: LocalStateContractArgs['tuple']['get_implicit_key_tuple(address)(uint64,byte[],bool)'] + returns: LocalStateContractReturns['get_implicit_key_tuple(address)(uint64,byte[],bool)'] + }> + & Record<'get_arc4_uint(address)uint64' | 'get_arc4_uint', { + argsObj: LocalStateContractArgs['obj']['get_arc4_uint(address)uint64'] + argsTuple: LocalStateContractArgs['tuple']['get_arc4_uint(address)uint64'] + returns: LocalStateContractReturns['get_arc4_uint(address)uint64'] + }> + & Record<'get_arc4_string(address)string' | 'get_arc4_string', { + argsObj: LocalStateContractArgs['obj']['get_arc4_string(address)string'] + argsTuple: LocalStateContractArgs['tuple']['get_arc4_string(address)string'] + returns: LocalStateContractReturns['get_arc4_string(address)string'] + }> + & Record<'get_arc4_byte(address)byte' | 'get_arc4_byte', { + argsObj: LocalStateContractArgs['obj']['get_arc4_byte(address)byte'] + argsTuple: LocalStateContractArgs['tuple']['get_arc4_byte(address)byte'] + returns: LocalStateContractReturns['get_arc4_byte(address)byte'] + }> + & Record<'get_arc4_bool(address)bool' | 'get_arc4_bool', { + argsObj: LocalStateContractArgs['obj']['get_arc4_bool(address)bool'] + argsTuple: LocalStateContractArgs['tuple']['get_arc4_bool(address)bool'] + returns: LocalStateContractReturns['get_arc4_bool(address)bool'] + }> + & Record<'get_arc4_address(address)address' | 'get_arc4_address', { + argsObj: LocalStateContractArgs['obj']['get_arc4_address(address)address'] + argsTuple: LocalStateContractArgs['tuple']['get_arc4_address(address)address'] + returns: LocalStateContractReturns['get_arc4_address(address)address'] + }> + & Record<'get_arc4_uint128(address)uint128' | 'get_arc4_uint128', { + argsObj: LocalStateContractArgs['obj']['get_arc4_uint128(address)uint128'] + argsTuple: LocalStateContractArgs['tuple']['get_arc4_uint128(address)uint128'] + returns: LocalStateContractReturns['get_arc4_uint128(address)uint128'] + }> + & Record<'get_arc4_dynamic_bytes(address)byte[]' | 'get_arc4_dynamic_bytes', { + argsObj: LocalStateContractArgs['obj']['get_arc4_dynamic_bytes(address)byte[]'] + argsTuple: LocalStateContractArgs['tuple']['get_arc4_dynamic_bytes(address)byte[]'] + returns: LocalStateContractReturns['get_arc4_dynamic_bytes(address)byte[]'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + local: { + keys: { + implicitKeyArc4Uint: bigint + implicitKeyArc4String: string + implicitKeyArc4Byte: number + implicitKeyArc4Bool: boolean + implicitKeyArc4Address: string + implicitKeyArc4Uint128: bigint + implicitKeyArc4DynamicBytes: Uint8Array + implicitKeyTuple: [bigint, Uint8Array, boolean] + arc4Uint: bigint + arc4String: string + arc4Byte: number + arc4Bool: boolean + arc4Address: string + arc4Uint128: bigint + arc4DynamicBytes: Uint8Array + } + maps: {} + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type LocalStateContractSignatures = keyof LocalStateContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type LocalStateContractNonVoidMethodSignatures = keyof LocalStateContractTypes['methods'] extends infer T ? T extends keyof LocalStateContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the LocalStateContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = LocalStateContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the LocalStateContract smart contract to the method's return type + */ +export type MethodReturn = LocalStateContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed local state of the application. + */ +export type LocalKeysState = LocalStateContractTypes['state']['local']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type LocalStateContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type LocalStateContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: LocalStateContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the LocalStateContract smart contract + */ +export abstract class LocalStateContractParamsFactory { + /** + * Gets available optIn ABI call param factories + */ + static get optIn() { + return { + /** + * Constructs opt-in ABI call params for the LocalStateContract smart contract using the opt_in()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + optIn(params: CallParams): AppClientMethodCallParams { + return { + ...params, + method: 'opt_in()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + }, + } + } + + /** + * Constructs a no op call for the get_implicit_key_arc4_uint(address)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Uint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_uint(address)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_string(address)string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4String(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_string(address)string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_byte(address)byte ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Byte(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_byte(address)byte' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_bool(address)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Bool(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_bool(address)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_address(address)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Address(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_address(address)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_uint128(address)uint128 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4Uint128(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_uint128(address)uint128' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_implicit_key_arc4_dynamic_bytes(address)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyArc4DynamicBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_arc4_dynamic_bytes(address)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_implicit_key_tuple(address)(uint64,byte[],bool) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getImplicitKeyTuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_implicit_key_tuple(address)(uint64,byte[],bool)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_arc4_uint(address)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Uint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_uint(address)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_arc4_string(address)string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4String(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_string(address)string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_arc4_byte(address)byte ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Byte(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_byte(address)byte' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_arc4_bool(address)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Bool(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_bool(address)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_arc4_address(address)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Address(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_address(address)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_arc4_uint128(address)uint128 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4Uint128(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_uint128(address)uint128' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the get_arc4_dynamic_bytes(address)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static getArc4DynamicBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get_arc4_dynamic_bytes(address)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } +} + +/** + * A factory to create and deploy one or more instance of the LocalStateContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class LocalStateContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `LocalStateContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new LocalStateContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new LocalStateContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the LocalStateContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: LocalStateContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new LocalStateContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the LocalStateContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the LocalStateContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the LocalStateContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new LocalStateContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the LocalStateContract smart contract + */ +export class LocalStateContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `LocalStateContractClient` + * + * @param appClient An `AppClient` instance which has been created with the LocalStateContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `LocalStateContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `LocalStateContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new LocalStateContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `LocalStateContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new LocalStateContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the LocalStateContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn params + */ + optIn: (params: CallParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + return this.appClient.params.optIn(LocalStateContractParamsFactory.optIn.optIn(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the LocalStateContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_uint(address)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getImplicitKeyArc4Uint(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_string(address)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getImplicitKeyArc4String(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_byte(address)byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getImplicitKeyArc4Byte(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_bool(address)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getImplicitKeyArc4Bool(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_address(address)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getImplicitKeyArc4Address(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_uint128(address)uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getImplicitKeyArc4Uint128(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_dynamic_bytes(address)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getImplicitKeyArc4DynamicBytes(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_tuple(address)(uint64,byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getImplicitKeyTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getImplicitKeyTuple(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_uint(address)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getArc4Uint(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_string(address)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getArc4String(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_byte(address)byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getArc4Byte(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_bool(address)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getArc4Bool(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_address(address)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getArc4Address(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_uint128(address)uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getArc4Uint128(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_dynamic_bytes(address)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + getArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(LocalStateContractParamsFactory.getArc4DynamicBytes(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the LocalStateContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn transaction + */ + optIn: (params: CallParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + return this.appClient.createTransaction.optIn(LocalStateContractParamsFactory.optIn.optIn(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the LocalStateContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_uint(address)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getImplicitKeyArc4Uint(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_string(address)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getImplicitKeyArc4String(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_byte(address)byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getImplicitKeyArc4Byte(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_bool(address)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getImplicitKeyArc4Bool(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_address(address)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getImplicitKeyArc4Address(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_uint128(address)uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getImplicitKeyArc4Uint128(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_dynamic_bytes(address)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getImplicitKeyArc4DynamicBytes(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_tuple(address)(uint64,byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getImplicitKeyTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getImplicitKeyTuple(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_uint(address)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Uint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getArc4Uint(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_string(address)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4String: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getArc4String(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_byte(address)byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Byte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getArc4Byte(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_bool(address)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getArc4Bool(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_address(address)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Address: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getArc4Address(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_uint128(address)uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4Uint128: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getArc4Uint128(params)) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_dynamic_bytes(address)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + getArc4DynamicBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(LocalStateContractParamsFactory.getArc4DynamicBytes(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the LocalStateContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn result + */ + optIn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + const result = await this.appClient.send.optIn(LocalStateContractParamsFactory.optIn.optIn(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['opt_in()void'])} + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the LocalStateContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_uint(address)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Uint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getImplicitKeyArc4Uint(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_implicit_key_arc4_uint(address)uint64'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_string(address)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4String: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getImplicitKeyArc4String(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_implicit_key_arc4_string(address)string'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_byte(address)byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Byte: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getImplicitKeyArc4Byte(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_implicit_key_arc4_byte(address)byte'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_bool(address)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Bool: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getImplicitKeyArc4Bool(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_implicit_key_arc4_bool(address)bool'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_address(address)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Address: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getImplicitKeyArc4Address(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_implicit_key_arc4_address(address)address'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_uint128(address)uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4Uint128: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getImplicitKeyArc4Uint128(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_implicit_key_arc4_uint128(address)uint128'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_arc4_dynamic_bytes(address)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyArc4DynamicBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getImplicitKeyArc4DynamicBytes(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_implicit_key_arc4_dynamic_bytes(address)byte[]'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_implicit_key_tuple(address)(uint64,byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getImplicitKeyTuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getImplicitKeyTuple(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_implicit_key_tuple(address)(uint64,byte[],bool)'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_uint(address)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Uint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getArc4Uint(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_arc4_uint(address)uint64'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_string(address)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4String: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getArc4String(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_arc4_string(address)string'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_byte(address)byte` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Byte: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getArc4Byte(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_arc4_byte(address)byte'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_bool(address)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Bool: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getArc4Bool(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_arc4_bool(address)bool'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_address(address)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Address: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getArc4Address(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_arc4_address(address)address'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_uint128(address)uint128` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4Uint128: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getArc4Uint128(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_arc4_uint128(address)uint128'])} + }, + + /** + * Makes a call to the LocalStateContract smart contract using the `get_arc4_dynamic_bytes(address)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + getArc4DynamicBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(LocalStateContractParamsFactory.getArc4DynamicBytes(params)) + return {...result, return: result.return as unknown as (undefined | LocalStateContractReturns['get_arc4_dynamic_bytes(address)byte[]'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new LocalStateContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current LocalStateContract app + */ + state = { + /** + * Methods to access local state for the current LocalStateContract app + */ + local: (address: string | Address) => { + const encodedAddress = typeof address === 'string' ? address : encodeAddress(address.publicKey) + return { + /** + * Get all current keyed values from local state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.local(encodedAddress).getAll() + return { + implicitKeyArc4Uint: result.implicit_key_arc4_uint, + implicitKeyArc4String: result.implicit_key_arc4_string, + implicitKeyArc4Byte: result.implicit_key_arc4_byte, + implicitKeyArc4Bool: result.implicit_key_arc4_bool, + implicitKeyArc4Address: result.implicit_key_arc4_address, + implicitKeyArc4Uint128: result.implicit_key_arc4_uint128, + implicitKeyArc4DynamicBytes: result.implicit_key_arc4_dynamic_bytes, + implicitKeyTuple: result.implicit_key_tuple, + arc4Uint: result.arc4_uint, + arc4String: result.arc4_string, + arc4Byte: result.arc4_byte, + arc4Bool: result.arc4_bool, + arc4Address: result.arc4_address, + arc4Uint128: result.arc4_uint128, + arc4DynamicBytes: result.arc4_dynamic_bytes, + } + }, + /** + * Get the current value of the implicit_key_arc4_uint key in local state + */ + implicitKeyArc4Uint: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("implicit_key_arc4_uint")) as bigint | undefined }, + /** + * Get the current value of the implicit_key_arc4_string key in local state + */ + implicitKeyArc4String: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("implicit_key_arc4_string")) as string | undefined }, + /** + * Get the current value of the implicit_key_arc4_byte key in local state + */ + implicitKeyArc4Byte: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("implicit_key_arc4_byte")) as number | undefined }, + /** + * Get the current value of the implicit_key_arc4_bool key in local state + */ + implicitKeyArc4Bool: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("implicit_key_arc4_bool")) as boolean | undefined }, + /** + * Get the current value of the implicit_key_arc4_address key in local state + */ + implicitKeyArc4Address: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("implicit_key_arc4_address")) as string | undefined }, + /** + * Get the current value of the implicit_key_arc4_uint128 key in local state + */ + implicitKeyArc4Uint128: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("implicit_key_arc4_uint128")) as bigint | undefined }, + /** + * Get the current value of the implicit_key_arc4_dynamic_bytes key in local state + */ + implicitKeyArc4DynamicBytes: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("implicit_key_arc4_dynamic_bytes")) as Uint8Array | undefined }, + /** + * Get the current value of the implicit_key_tuple key in local state + */ + implicitKeyTuple: async (): Promise<[bigint, Uint8Array, boolean] | undefined> => { return (await this.appClient.state.local(encodedAddress).getValue("implicit_key_tuple")) as [bigint, Uint8Array, boolean] | undefined }, + /** + * Get the current value of the arc4_uint key in local state + */ + arc4Uint: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("arc4_uint")) as bigint | undefined }, + /** + * Get the current value of the arc4_string key in local state + */ + arc4String: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("arc4_string")) as string | undefined }, + /** + * Get the current value of the arc4_byte key in local state + */ + arc4Byte: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("arc4_byte")) as number | undefined }, + /** + * Get the current value of the arc4_bool key in local state + */ + arc4Bool: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("arc4_bool")) as boolean | undefined }, + /** + * Get the current value of the arc4_address key in local state + */ + arc4Address: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("arc4_address")) as string | undefined }, + /** + * Get the current value of the arc4_uint128 key in local state + */ + arc4Uint128: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("arc4_uint128")) as bigint | undefined }, + /** + * Get the current value of the arc4_dynamic_bytes key in local state + */ + arc4DynamicBytes: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("arc4_dynamic_bytes")) as Uint8Array | undefined }, + } + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): LocalStateContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a get_implicit_key_arc4_uint(address)uint64 method call against the LocalStateContract contract + */ + getImplicitKeyArc4Uint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Uint(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_string(address)string method call against the LocalStateContract contract + */ + getImplicitKeyArc4String(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4String(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_byte(address)byte method call against the LocalStateContract contract + */ + getImplicitKeyArc4Byte(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Byte(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_bool(address)bool method call against the LocalStateContract contract + */ + getImplicitKeyArc4Bool(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Bool(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_address(address)address method call against the LocalStateContract contract + */ + getImplicitKeyArc4Address(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Address(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_uint128(address)uint128 method call against the LocalStateContract contract + */ + getImplicitKeyArc4Uint128(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4Uint128(params))) + return this + }, + /** + * Add a get_implicit_key_arc4_dynamic_bytes(address)byte[] method call against the LocalStateContract contract + */ + getImplicitKeyArc4DynamicBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyArc4DynamicBytes(params))) + return this + }, + /** + * Add a get_implicit_key_tuple(address)(uint64,byte[],bool) method call against the LocalStateContract contract + */ + getImplicitKeyTuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getImplicitKeyTuple(params))) + return this + }, + /** + * Add a get_arc4_uint(address)uint64 method call against the LocalStateContract contract + */ + getArc4Uint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Uint(params))) + return this + }, + /** + * Add a get_arc4_string(address)string method call against the LocalStateContract contract + */ + getArc4String(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4String(params))) + return this + }, + /** + * Add a get_arc4_byte(address)byte method call against the LocalStateContract contract + */ + getArc4Byte(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Byte(params))) + return this + }, + /** + * Add a get_arc4_bool(address)bool method call against the LocalStateContract contract + */ + getArc4Bool(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Bool(params))) + return this + }, + /** + * Add a get_arc4_address(address)address method call against the LocalStateContract contract + */ + getArc4Address(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Address(params))) + return this + }, + /** + * Add a get_arc4_uint128(address)uint128 method call against the LocalStateContract contract + */ + getArc4Uint128(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4Uint128(params))) + return this + }, + /** + * Add a get_arc4_dynamic_bytes(address)byte[] method call against the LocalStateContract contract + */ + getArc4DynamicBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.getArc4DynamicBytes(params))) + return this + }, + get optIn() { + return { + optIn: (params: CallParams) => { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.optIn.optIn(params))) + return this + }, + } + }, + /** + * Add a clear state call to the LocalStateContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as LocalStateContractComposer + } +} +export type LocalStateContractComposer = { + /** + * Calls the get_implicit_key_arc4_uint(address)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Uint(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_implicit_key_arc4_uint(address)uint64'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_string(address)string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4String(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_implicit_key_arc4_string(address)string'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_byte(address)byte ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Byte(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_implicit_key_arc4_byte(address)byte'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_bool(address)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Bool(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_implicit_key_arc4_bool(address)bool'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_address(address)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Address(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_implicit_key_arc4_address(address)address'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_uint128(address)uint128 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4Uint128(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_implicit_key_arc4_uint128(address)uint128'] | undefined]> + + /** + * Calls the get_implicit_key_arc4_dynamic_bytes(address)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyArc4DynamicBytes(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_implicit_key_arc4_dynamic_bytes(address)byte[]'] | undefined]> + + /** + * Calls the get_implicit_key_tuple(address)(uint64,byte[],bool) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getImplicitKeyTuple(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_implicit_key_tuple(address)(uint64,byte[],bool)'] | undefined]> + + /** + * Calls the get_arc4_uint(address)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Uint(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_arc4_uint(address)uint64'] | undefined]> + + /** + * Calls the get_arc4_string(address)string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4String(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_arc4_string(address)string'] | undefined]> + + /** + * Calls the get_arc4_byte(address)byte ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Byte(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_arc4_byte(address)byte'] | undefined]> + + /** + * Calls the get_arc4_bool(address)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Bool(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_arc4_bool(address)bool'] | undefined]> + + /** + * Calls the get_arc4_address(address)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Address(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_arc4_address(address)address'] | undefined]> + + /** + * Calls the get_arc4_uint128(address)uint128 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4Uint128(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_arc4_uint128(address)uint128'] | undefined]> + + /** + * Calls the get_arc4_dynamic_bytes(address)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + getArc4DynamicBytes(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['get_arc4_dynamic_bytes(address)byte[]'] | undefined]> + + /** + * Gets available optIn methods + */ + readonly optIn: { + /** + * Opts the user into an existing instance of the LocalStateContract smart contract using the opt_in()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + optIn(params?: CallParams): LocalStateContractComposer<[...TReturns, LocalStateContractReturns['opt_in()void'] | undefined]> + } + + /** + * Makes a clear_state call to an existing instance of the LocalStateContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): LocalStateContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): LocalStateContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type LocalStateContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/MiscellaneousOpsContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/MiscellaneousOpsContract.ts new file mode 100644 index 0000000..afd9e82 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/MiscellaneousOpsContract.ts @@ -0,0 +1,3082 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"MiscellaneousOpsContract","structs":{},"methods":[{"name":"verify_addw","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"(uint64,uint64)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_base64_decode_standard","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_base64_decode_url","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_bitlen","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"pad_a_size"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_bitlen","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bsqrt","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_btoi","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bzero","args":[{"type":"uint64","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_concat","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"},{"type":"uint64","name":"pad_a_size"},{"type":"uint64","name":"pad_b_size"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_divmodw","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"},{"type":"uint64","name":"c"},{"type":"uint64","name":"d"}],"returns":{"type":"(uint64,uint64,uint64,uint64)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_divw","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"},{"type":"uint64","name":"c"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_err","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_exp","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_expw","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"(uint64,uint64)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_extract","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"},{"type":"uint64","name":"c"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_extract_from_2","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_extract_uint16","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_extract_uint32","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_extract_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_getbit_bytes","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_getbit_uint64","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_getbyte","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_itob","args":[{"type":"uint64","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_mulw","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"(uint64,uint64)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_replace","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"},{"type":"byte[]","name":"c"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_select_bytes","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"},{"type":"uint64","name":"c"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_select_uint64","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"},{"type":"uint64","name":"c"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_setbit_bytes","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"},{"type":"bool","name":"c"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_setbit_uint64","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"},{"type":"bool","name":"c"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_setbyte","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"},{"type":"uint64","name":"c"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_shl","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_shr","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_sqrt","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_substring","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"},{"type":"uint64","name":"c"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_json_ref_string","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_json_ref_uint64","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_json_ref_object","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75 0x151f7c750020 0x00
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@44
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x45847eea 0xf57aceb5 0x7d631730 0xa1b24441 0xcd7be1ac 0x7cfda64b 0x54a910d9 0xc46568de 0x7a46a6ae 0x04372209 0x7e5f6d72 0x24ebcf84 0x9c0b3397 0x0ad40da4 0x95178870 0xdeedc99b 0xab2150bb 0x02a54017 0x3db66b41 0x6e3ff38c 0x8f3b9f18 0x16166f9a 0x2f472065 0xd5a739c3 0x61f3b3e1 0x56cf368b 0x919ffbd2 0xaae8b697 0x847422b1 0xd5260327 0x114c8c6d 0x39e9e62a 0xd6a4c05e 0x1ef8151a 0x66dd7f96 0x4d9eceb2 0x19ba70ee // method "verify_addw(uint64,uint64)(uint64,uint64)", method "verify_base64_decode_standard(byte[])byte[]", method "verify_base64_decode_url(byte[])byte[]", method "verify_bytes_bitlen(byte[],uint64)uint64", method "verify_uint64_bitlen(uint64)uint64", method "verify_bsqrt(byte[])byte[]", method "verify_btoi(byte[])uint64", method "verify_bzero(uint64)byte[]", method "verify_concat(byte[],byte[],uint64,uint64)byte[]", method "verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)", method "verify_divw(uint64,uint64,uint64)uint64", method "verify_err()void", method "verify_exp(uint64,uint64)uint64", method "verify_expw(uint64,uint64)(uint64,uint64)", method "verify_extract(byte[],uint64,uint64)byte[]", method "verify_extract_from_2(byte[])byte[]", method "verify_extract_uint16(byte[],uint64)uint64", method "verify_extract_uint32(byte[],uint64)uint64", method "verify_extract_uint64(byte[],uint64)uint64", method "verify_getbit_bytes(byte[],uint64)bool", method "verify_getbit_uint64(uint64,uint64)bool", method "verify_getbyte(byte[],uint64)uint64", method "verify_itob(uint64)byte[]", method "verify_mulw(uint64,uint64)(uint64,uint64)", method "verify_replace(byte[],uint64,byte[])byte[]", method "verify_select_bytes(byte[],byte[],uint64)byte[]", method "verify_select_uint64(uint64,uint64,uint64)uint64", method "verify_setbit_bytes(byte[],uint64,bool)byte[]", method "verify_setbit_uint64(uint64,uint64,bool)uint64", method "verify_setbyte(byte[],uint64,uint64)byte[]", method "verify_shl(uint64,uint64)uint64", method "verify_shr(uint64,uint64)uint64", method "verify_sqrt(uint64)uint64", method "verify_substring(byte[],uint64,uint64)byte[]", method "verify_json_ref_string(byte[],byte[])byte[]", method "verify_json_ref_uint64(byte[],byte[])uint64", method "verify_json_ref_object(byte[],byte[])byte[]"
    txna ApplicationArgs 0
    match verify_addw verify_base64_decode_standard verify_base64_decode_url verify_bytes_bitlen verify_uint64_bitlen verify_bsqrt verify_btoi verify_bzero verify_concat verify_divmodw verify_divw main_verify_err_route@15 verify_exp verify_expw verify_extract verify_extract_from_2 verify_extract_uint16 verify_extract_uint32 verify_extract_uint64 verify_getbit_bytes verify_getbit_uint64 verify_getbyte verify_itob verify_mulw verify_replace verify_select_bytes verify_select_uint64 verify_setbit_bytes verify_setbit_uint64 verify_setbyte verify_shl verify_shr verify_sqrt verify_substring verify_json_ref_string verify_json_ref_uint64 verify_json_ref_object
    err

main_verify_err_route@15:
    // tests/artifacts/MiscellaneousOps/contract.py:69
    // op.err()
    err

main___algopy_default_create@44:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_addw[routing]() -> void:
verify_addw:
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:7
    // result = op.addw(a, b)
    addw
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_standard[routing]() -> void:
verify_base64_decode_standard:
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:12
    // result = op.base64_decode(op.Base64.StdEncoding, a)
    base64_decode StdEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_url[routing]() -> void:
verify_base64_decode_url:
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:17
    // result = op.base64_decode(op.Base64.URLEncoding, a)
    base64_decode URLEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bytes_bitlen[routing]() -> void:
verify_bytes_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:22
    // a = op.bzero(pad_a_size) + a
    bzero
    swap
    concat
    // tests/artifacts/MiscellaneousOps/contract.py:23
    // result = op.bitlen(a)
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_uint64_bitlen[routing]() -> void:
verify_uint64_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:28
    // result = op.bitlen(a)
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bsqrt[routing]() -> void:
verify_bsqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:34
    // result = op.bsqrt(a_biguint)
    bsqrt
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_btoi[routing]() -> void:
verify_btoi:
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:39
    // result = op.btoi(a)
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bzero[routing]() -> void:
verify_bzero:
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:44
    // result = op.bzero(a)
    bzero
    // tests/artifacts/MiscellaneousOps/contract.py:45
    // return op.sha256(result)
    sha256
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    bytec_1 // 0x151f7c750020
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_concat[routing]() -> void:
verify_concat:
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:49
    // a = op.bzero(pad_a_size) + a
    swap
    bzero
    uncover 3
    concat
    // tests/artifacts/MiscellaneousOps/contract.py:50
    // b = op.bzero(pad_b_size) + b
    swap
    bzero
    uncover 2
    concat
    // tests/artifacts/MiscellaneousOps/contract.py:51
    // result = a + b
    concat
    // tests/artifacts/MiscellaneousOps/contract.py:52
    // result = op.sha256(result)
    sha256
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    bytec_1 // 0x151f7c750020
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divmodw[routing]() -> void:
verify_divmodw:
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:59
    // result = op.divmodw(a, b, c, d)
    divmodw
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    uncover 3
    itob
    uncover 3
    itob
    concat
    uncover 2
    itob
    concat
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divw[routing]() -> void:
verify_divw:
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:64
    // result = op.divw(a, b, c)
    divw
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_exp[routing]() -> void:
verify_exp:
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:73
    // result = op.exp(a, b)
    exp
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_expw[routing]() -> void:
verify_expw:
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:78
    // result = op.expw(a, b)
    expw
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract[routing]() -> void:
verify_extract:
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:83
    // result = op.extract(a, b, c)
    extract3
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_from_2[routing]() -> void:
verify_extract_from_2:
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/MiscellaneousOps/contract.py:88
    // result = op.extract(a, 2, 0)
    extract 4 0
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint16[routing]() -> void:
verify_extract_uint16:
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:93
    // result = op.extract_uint16(a, b)
    extract_uint16
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint32[routing]() -> void:
verify_extract_uint32:
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:98
    // result = op.extract_uint32(a, b)
    extract_uint32
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint64[routing]() -> void:
verify_extract_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    pushint 8
    extract3
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_bytes[routing]() -> void:
verify_getbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:108
    // result = op.getbit(a, b)
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    bytec_2 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_uint64[routing]() -> void:
verify_getbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:113
    // result = op.getbit(a, b)
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    bytec_2 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbyte[routing]() -> void:
verify_getbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:118
    // result = op.getbyte(a, b)
    getbyte
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_itob[routing]() -> void:
verify_itob:
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:123
    // result = op.itob(a)
    itob
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    pushbytes 0x151f7c750008
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_mulw[routing]() -> void:
verify_mulw:
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:128
    // result = op.mulw(a, b)
    mulw
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_replace[routing]() -> void:
verify_replace:
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:133
    // result = op.replace(a, b, c)
    replace3
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_bytes[routing]() -> void:
verify_select_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:138
    // result = op.select_bytes(a, b, c)
    select
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_uint64[routing]() -> void:
verify_select_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:143
    // result = op.select_uint64(a, b, c)
    select
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_bytes[routing]() -> void:
verify_setbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    intc_1 // 0
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:148
    // result = op.setbit_bytes(a, b, c)
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_uint64[routing]() -> void:
verify_setbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    intc_1 // 0
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:153
    // result = op.setbit_uint64(a, b, c)
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbyte[routing]() -> void:
verify_setbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:158
    // result = op.setbyte(a, b, c)
    setbyte
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shl[routing]() -> void:
verify_shl:
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:163
    // result = op.shl(a, b)
    shl
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shr[routing]() -> void:
verify_shr:
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:168
    // result = op.shr(a, b)
    shr
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_sqrt[routing]() -> void:
verify_sqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:173
    // result = op.sqrt(a)
    sqrt
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_substring[routing]() -> void:
verify_substring:
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:178
    // result = op.substring(a, b, c)
    substring3
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_string[routing]() -> void:
verify_json_ref_string:
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:183
    // result = op.JsonRef.json_string(a, b)
    json_ref JSONString
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_uint64[routing]() -> void:
verify_json_ref_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:188
    // result = op.JsonRef.json_uint64(a, b)
    json_ref JSONUint64
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_object[routing]() -> void:
verify_json_ref_object:
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:193
    // result = op.JsonRef.json_object(a, b)
    json_ref JSONObject
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyACAQAmAwQVH3x1BhUffHUAIAEAMRtBARMxGRREMRhEgiUERYR+6gT1es61BH1jFzAEobJEQQTNe+GsBHz9pksEVKkQ2QTEZWjeBHpGpq4EBDciCQR+X21yBCTrz4QEnAszlwQK1A2kBJUXiHAE3u3JmwSrIVC7BAKlQBcEPbZrQQRuP/OMBI87nxgEFhZvmgQvRyBlBNWnOcMEYfOz4QRWzzaLBJGf+9IEqui2lwSEdCKxBNUmAycEEUyMbQQ56eYqBNakwF4EHvgVGgRm3X+WBE2ezrIEGbpw7jYaAI4lAAoAHgA0AEoAXwBrAIAAjgCaAMAA5QABAPkBCQEdAToBTgFgAXIBhQGbAa8BwQHTAecCBgIlAjkCVwJsAokCmQKpArUC0gLuAwMAADEZFDEYFBBDNhoBFzYaAhceTBZMFlAoTFCwIkM2GgFXAgBeAUkVFlcGAkxQKExQsCJDNhoBVwIAXgBJFRZXBgJMUChMULAiQzYaAVcCADYaAhevTFCTFihMULAiQzYaAReTFihMULAiQzYaAVcCAJZJFRZXBgJMUChMULAiQzYaAVcCABcWKExQsCJDNhoBF68BKUxQsCJDNhoBVwIANhoCVwIANhoDFzYaBBdMr08DUEyvTwJQUAEpTFCwIkM2GgEXNhoCFzYaAxc2GgQXH08DFk8DFlBPAhZQTBZQKExQsCJDNhoBFzYaAhc2GgMXlxYoTFCwIkM2GgEXNhoCF5QWKExQsCJDNhoBFzYaAheVTBZMFlAoTFCwIkM2GgFXAgA2GgIXNhoDF1hJFRZXBgJMUChMULAiQzYaAVcEAEkVFlcGAkxQKExQsCJDNhoBVwIANhoCF1kWKExQsCJDNhoBVwIANhoCF1oWKExQsCJDNhoBVwIANhoCF4EIWChMULAiQzYaAVcCADYaAhdTKiNPAlQoTFCwIkM2GgEXNhoCF1MqI08CVChMULAiQzYaAVcCADYaAhdVFihMULAiQzYaARcWgAYVH3x1AAhMULAiQzYaARc2GgIXHUwWTBZQKExQsCJDNhoBVwIANhoCFzYaA1cCAF1JFRZXBgJMUChMULAiQzYaAVcCADYaAlcCADYaAxdNSRUWVwYCTFAoTFCwIkM2GgEXNhoCFzYaAxdNFihMULAiQzYaAVcCADYaAhc2GgMjU1RJFRZXBgJMUChMULAiQzYaARc2GgIXNhoDI1NUFihMULAiQzYaAVcCADYaAhc2GgMXVkkVFlcGAkxQKExQsCJDNhoBFzYaAheQFihMULAiQzYaARc2GgIXkRYoTFCwIkM2GgEXkhYoTFCwIkM2GgFXAgA2GgIXNhoDF1JJFRZXBgJMUChMULAiQzYaAVcCADYaAlcCAF8ASRUWVwYCTFAoTFCwIkM2GgFXAgA2GgJXAgBfARYoTFCwIkM2GgFXAgA2GgJXAgBfAkkVFlcGAkxQKExQsCJD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the MiscellaneousOpsContract contract + */ +export type MiscellaneousOpsContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_addw(uint64,uint64)(uint64,uint64)': { + a: bigint | number + b: bigint | number + } + 'verify_base64_decode_standard(byte[])byte[]': { + a: Uint8Array + } + 'verify_base64_decode_url(byte[])byte[]': { + a: Uint8Array + } + 'verify_bytes_bitlen(byte[],uint64)uint64': { + a: Uint8Array + padASize: bigint | number + } + 'verify_uint64_bitlen(uint64)uint64': { + a: bigint | number + } + 'verify_bsqrt(byte[])byte[]': { + a: Uint8Array + } + 'verify_btoi(byte[])uint64': { + a: Uint8Array + } + 'verify_bzero(uint64)byte[]': { + a: bigint | number + } + 'verify_concat(byte[],byte[],uint64,uint64)byte[]': { + a: Uint8Array + b: Uint8Array + padASize: bigint | number + padBSize: bigint | number + } + 'verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)': { + a: bigint | number + b: bigint | number + c: bigint | number + d: bigint | number + } + 'verify_divw(uint64,uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + c: bigint | number + } + 'verify_err()void': Record + 'verify_exp(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_expw(uint64,uint64)(uint64,uint64)': { + a: bigint | number + b: bigint | number + } + 'verify_extract(byte[],uint64,uint64)byte[]': { + a: Uint8Array + b: bigint | number + c: bigint | number + } + 'verify_extract_from_2(byte[])byte[]': { + a: Uint8Array + } + 'verify_extract_uint16(byte[],uint64)uint64': { + a: Uint8Array + b: bigint | number + } + 'verify_extract_uint32(byte[],uint64)uint64': { + a: Uint8Array + b: bigint | number + } + 'verify_extract_uint64(byte[],uint64)uint64': { + a: Uint8Array + b: bigint | number + } + 'verify_getbit_bytes(byte[],uint64)bool': { + a: Uint8Array + b: bigint | number + } + 'verify_getbit_uint64(uint64,uint64)bool': { + a: bigint | number + b: bigint | number + } + 'verify_getbyte(byte[],uint64)uint64': { + a: Uint8Array + b: bigint | number + } + 'verify_itob(uint64)byte[]': { + a: bigint | number + } + 'verify_mulw(uint64,uint64)(uint64,uint64)': { + a: bigint | number + b: bigint | number + } + 'verify_replace(byte[],uint64,byte[])byte[]': { + a: Uint8Array + b: bigint | number + c: Uint8Array + } + 'verify_select_bytes(byte[],byte[],uint64)byte[]': { + a: Uint8Array + b: Uint8Array + c: bigint | number + } + 'verify_select_uint64(uint64,uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + c: bigint | number + } + 'verify_setbit_bytes(byte[],uint64,bool)byte[]': { + a: Uint8Array + b: bigint | number + c: boolean + } + 'verify_setbit_uint64(uint64,uint64,bool)uint64': { + a: bigint | number + b: bigint | number + c: boolean + } + 'verify_setbyte(byte[],uint64,uint64)byte[]': { + a: Uint8Array + b: bigint | number + c: bigint | number + } + 'verify_shl(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_shr(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_sqrt(uint64)uint64': { + a: bigint | number + } + 'verify_substring(byte[],uint64,uint64)byte[]': { + a: Uint8Array + b: bigint | number + c: bigint | number + } + 'verify_json_ref_string(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_json_ref_uint64(byte[],byte[])uint64': { + a: Uint8Array + b: Uint8Array + } + 'verify_json_ref_object(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_addw(uint64,uint64)(uint64,uint64)': [a: bigint | number, b: bigint | number] + 'verify_base64_decode_standard(byte[])byte[]': [a: Uint8Array] + 'verify_base64_decode_url(byte[])byte[]': [a: Uint8Array] + 'verify_bytes_bitlen(byte[],uint64)uint64': [a: Uint8Array, padASize: bigint | number] + 'verify_uint64_bitlen(uint64)uint64': [a: bigint | number] + 'verify_bsqrt(byte[])byte[]': [a: Uint8Array] + 'verify_btoi(byte[])uint64': [a: Uint8Array] + 'verify_bzero(uint64)byte[]': [a: bigint | number] + 'verify_concat(byte[],byte[],uint64,uint64)byte[]': [a: Uint8Array, b: Uint8Array, padASize: bigint | number, padBSize: bigint | number] + 'verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)': [a: bigint | number, b: bigint | number, c: bigint | number, d: bigint | number] + 'verify_divw(uint64,uint64,uint64)uint64': [a: bigint | number, b: bigint | number, c: bigint | number] + 'verify_err()void': [] + 'verify_exp(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_expw(uint64,uint64)(uint64,uint64)': [a: bigint | number, b: bigint | number] + 'verify_extract(byte[],uint64,uint64)byte[]': [a: Uint8Array, b: bigint | number, c: bigint | number] + 'verify_extract_from_2(byte[])byte[]': [a: Uint8Array] + 'verify_extract_uint16(byte[],uint64)uint64': [a: Uint8Array, b: bigint | number] + 'verify_extract_uint32(byte[],uint64)uint64': [a: Uint8Array, b: bigint | number] + 'verify_extract_uint64(byte[],uint64)uint64': [a: Uint8Array, b: bigint | number] + 'verify_getbit_bytes(byte[],uint64)bool': [a: Uint8Array, b: bigint | number] + 'verify_getbit_uint64(uint64,uint64)bool': [a: bigint | number, b: bigint | number] + 'verify_getbyte(byte[],uint64)uint64': [a: Uint8Array, b: bigint | number] + 'verify_itob(uint64)byte[]': [a: bigint | number] + 'verify_mulw(uint64,uint64)(uint64,uint64)': [a: bigint | number, b: bigint | number] + 'verify_replace(byte[],uint64,byte[])byte[]': [a: Uint8Array, b: bigint | number, c: Uint8Array] + 'verify_select_bytes(byte[],byte[],uint64)byte[]': [a: Uint8Array, b: Uint8Array, c: bigint | number] + 'verify_select_uint64(uint64,uint64,uint64)uint64': [a: bigint | number, b: bigint | number, c: bigint | number] + 'verify_setbit_bytes(byte[],uint64,bool)byte[]': [a: Uint8Array, b: bigint | number, c: boolean] + 'verify_setbit_uint64(uint64,uint64,bool)uint64': [a: bigint | number, b: bigint | number, c: boolean] + 'verify_setbyte(byte[],uint64,uint64)byte[]': [a: Uint8Array, b: bigint | number, c: bigint | number] + 'verify_shl(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_shr(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_sqrt(uint64)uint64': [a: bigint | number] + 'verify_substring(byte[],uint64,uint64)byte[]': [a: Uint8Array, b: bigint | number, c: bigint | number] + 'verify_json_ref_string(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_json_ref_uint64(byte[],byte[])uint64': [a: Uint8Array, b: Uint8Array] + 'verify_json_ref_object(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + } +} + +/** + * The return type for each method + */ +export type MiscellaneousOpsContractReturns = { + 'verify_addw(uint64,uint64)(uint64,uint64)': [bigint, bigint] + 'verify_base64_decode_standard(byte[])byte[]': Uint8Array + 'verify_base64_decode_url(byte[])byte[]': Uint8Array + 'verify_bytes_bitlen(byte[],uint64)uint64': bigint + 'verify_uint64_bitlen(uint64)uint64': bigint + 'verify_bsqrt(byte[])byte[]': Uint8Array + 'verify_btoi(byte[])uint64': bigint + 'verify_bzero(uint64)byte[]': Uint8Array + 'verify_concat(byte[],byte[],uint64,uint64)byte[]': Uint8Array + 'verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)': [bigint, bigint, bigint, bigint] + 'verify_divw(uint64,uint64,uint64)uint64': bigint + 'verify_err()void': void + 'verify_exp(uint64,uint64)uint64': bigint + 'verify_expw(uint64,uint64)(uint64,uint64)': [bigint, bigint] + 'verify_extract(byte[],uint64,uint64)byte[]': Uint8Array + 'verify_extract_from_2(byte[])byte[]': Uint8Array + 'verify_extract_uint16(byte[],uint64)uint64': bigint + 'verify_extract_uint32(byte[],uint64)uint64': bigint + 'verify_extract_uint64(byte[],uint64)uint64': bigint + 'verify_getbit_bytes(byte[],uint64)bool': boolean + 'verify_getbit_uint64(uint64,uint64)bool': boolean + 'verify_getbyte(byte[],uint64)uint64': bigint + 'verify_itob(uint64)byte[]': Uint8Array + 'verify_mulw(uint64,uint64)(uint64,uint64)': [bigint, bigint] + 'verify_replace(byte[],uint64,byte[])byte[]': Uint8Array + 'verify_select_bytes(byte[],byte[],uint64)byte[]': Uint8Array + 'verify_select_uint64(uint64,uint64,uint64)uint64': bigint + 'verify_setbit_bytes(byte[],uint64,bool)byte[]': Uint8Array + 'verify_setbit_uint64(uint64,uint64,bool)uint64': bigint + 'verify_setbyte(byte[],uint64,uint64)byte[]': Uint8Array + 'verify_shl(uint64,uint64)uint64': bigint + 'verify_shr(uint64,uint64)uint64': bigint + 'verify_sqrt(uint64)uint64': bigint + 'verify_substring(byte[],uint64,uint64)byte[]': Uint8Array + 'verify_json_ref_string(byte[],byte[])byte[]': Uint8Array + 'verify_json_ref_uint64(byte[],byte[])uint64': bigint + 'verify_json_ref_object(byte[],byte[])byte[]': Uint8Array +} + +/** + * Defines the types of available calls and state of the MiscellaneousOpsContract smart contract. + */ +export type MiscellaneousOpsContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_addw(uint64,uint64)(uint64,uint64)' | 'verify_addw', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_addw(uint64,uint64)(uint64,uint64)'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_addw(uint64,uint64)(uint64,uint64)'] + returns: MiscellaneousOpsContractReturns['verify_addw(uint64,uint64)(uint64,uint64)'] + }> + & Record<'verify_base64_decode_standard(byte[])byte[]' | 'verify_base64_decode_standard', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_base64_decode_standard(byte[])byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_base64_decode_standard(byte[])byte[]'] + returns: MiscellaneousOpsContractReturns['verify_base64_decode_standard(byte[])byte[]'] + }> + & Record<'verify_base64_decode_url(byte[])byte[]' | 'verify_base64_decode_url', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_base64_decode_url(byte[])byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_base64_decode_url(byte[])byte[]'] + returns: MiscellaneousOpsContractReturns['verify_base64_decode_url(byte[])byte[]'] + }> + & Record<'verify_bytes_bitlen(byte[],uint64)uint64' | 'verify_bytes_bitlen', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_bytes_bitlen(byte[],uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_bytes_bitlen(byte[],uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_bytes_bitlen(byte[],uint64)uint64'] + }> + & Record<'verify_uint64_bitlen(uint64)uint64' | 'verify_uint64_bitlen', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_uint64_bitlen(uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_uint64_bitlen(uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_uint64_bitlen(uint64)uint64'] + }> + & Record<'verify_bsqrt(byte[])byte[]' | 'verify_bsqrt', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_bsqrt(byte[])byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_bsqrt(byte[])byte[]'] + returns: MiscellaneousOpsContractReturns['verify_bsqrt(byte[])byte[]'] + }> + & Record<'verify_btoi(byte[])uint64' | 'verify_btoi', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_btoi(byte[])uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_btoi(byte[])uint64'] + returns: MiscellaneousOpsContractReturns['verify_btoi(byte[])uint64'] + }> + & Record<'verify_bzero(uint64)byte[]' | 'verify_bzero', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_bzero(uint64)byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_bzero(uint64)byte[]'] + returns: MiscellaneousOpsContractReturns['verify_bzero(uint64)byte[]'] + }> + & Record<'verify_concat(byte[],byte[],uint64,uint64)byte[]' | 'verify_concat', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_concat(byte[],byte[],uint64,uint64)byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_concat(byte[],byte[],uint64,uint64)byte[]'] + returns: MiscellaneousOpsContractReturns['verify_concat(byte[],byte[],uint64,uint64)byte[]'] + }> + & Record<'verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)' | 'verify_divmodw', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)'] + returns: MiscellaneousOpsContractReturns['verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)'] + }> + & Record<'verify_divw(uint64,uint64,uint64)uint64' | 'verify_divw', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_divw(uint64,uint64,uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_divw(uint64,uint64,uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_divw(uint64,uint64,uint64)uint64'] + }> + & Record<'verify_err()void' | 'verify_err', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_err()void'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_err()void'] + returns: MiscellaneousOpsContractReturns['verify_err()void'] + }> + & Record<'verify_exp(uint64,uint64)uint64' | 'verify_exp', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_exp(uint64,uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_exp(uint64,uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_exp(uint64,uint64)uint64'] + }> + & Record<'verify_expw(uint64,uint64)(uint64,uint64)' | 'verify_expw', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_expw(uint64,uint64)(uint64,uint64)'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_expw(uint64,uint64)(uint64,uint64)'] + returns: MiscellaneousOpsContractReturns['verify_expw(uint64,uint64)(uint64,uint64)'] + }> + & Record<'verify_extract(byte[],uint64,uint64)byte[]' | 'verify_extract', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_extract(byte[],uint64,uint64)byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_extract(byte[],uint64,uint64)byte[]'] + returns: MiscellaneousOpsContractReturns['verify_extract(byte[],uint64,uint64)byte[]'] + }> + & Record<'verify_extract_from_2(byte[])byte[]' | 'verify_extract_from_2', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_extract_from_2(byte[])byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_extract_from_2(byte[])byte[]'] + returns: MiscellaneousOpsContractReturns['verify_extract_from_2(byte[])byte[]'] + }> + & Record<'verify_extract_uint16(byte[],uint64)uint64' | 'verify_extract_uint16', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_extract_uint16(byte[],uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_extract_uint16(byte[],uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_extract_uint16(byte[],uint64)uint64'] + }> + & Record<'verify_extract_uint32(byte[],uint64)uint64' | 'verify_extract_uint32', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_extract_uint32(byte[],uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_extract_uint32(byte[],uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_extract_uint32(byte[],uint64)uint64'] + }> + & Record<'verify_extract_uint64(byte[],uint64)uint64' | 'verify_extract_uint64', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_extract_uint64(byte[],uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_extract_uint64(byte[],uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_extract_uint64(byte[],uint64)uint64'] + }> + & Record<'verify_getbit_bytes(byte[],uint64)bool' | 'verify_getbit_bytes', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_getbit_bytes(byte[],uint64)bool'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_getbit_bytes(byte[],uint64)bool'] + returns: MiscellaneousOpsContractReturns['verify_getbit_bytes(byte[],uint64)bool'] + }> + & Record<'verify_getbit_uint64(uint64,uint64)bool' | 'verify_getbit_uint64', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_getbit_uint64(uint64,uint64)bool'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_getbit_uint64(uint64,uint64)bool'] + returns: MiscellaneousOpsContractReturns['verify_getbit_uint64(uint64,uint64)bool'] + }> + & Record<'verify_getbyte(byte[],uint64)uint64' | 'verify_getbyte', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_getbyte(byte[],uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_getbyte(byte[],uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_getbyte(byte[],uint64)uint64'] + }> + & Record<'verify_itob(uint64)byte[]' | 'verify_itob', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_itob(uint64)byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_itob(uint64)byte[]'] + returns: MiscellaneousOpsContractReturns['verify_itob(uint64)byte[]'] + }> + & Record<'verify_mulw(uint64,uint64)(uint64,uint64)' | 'verify_mulw', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_mulw(uint64,uint64)(uint64,uint64)'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_mulw(uint64,uint64)(uint64,uint64)'] + returns: MiscellaneousOpsContractReturns['verify_mulw(uint64,uint64)(uint64,uint64)'] + }> + & Record<'verify_replace(byte[],uint64,byte[])byte[]' | 'verify_replace', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_replace(byte[],uint64,byte[])byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_replace(byte[],uint64,byte[])byte[]'] + returns: MiscellaneousOpsContractReturns['verify_replace(byte[],uint64,byte[])byte[]'] + }> + & Record<'verify_select_bytes(byte[],byte[],uint64)byte[]' | 'verify_select_bytes', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_select_bytes(byte[],byte[],uint64)byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_select_bytes(byte[],byte[],uint64)byte[]'] + returns: MiscellaneousOpsContractReturns['verify_select_bytes(byte[],byte[],uint64)byte[]'] + }> + & Record<'verify_select_uint64(uint64,uint64,uint64)uint64' | 'verify_select_uint64', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_select_uint64(uint64,uint64,uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_select_uint64(uint64,uint64,uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_select_uint64(uint64,uint64,uint64)uint64'] + }> + & Record<'verify_setbit_bytes(byte[],uint64,bool)byte[]' | 'verify_setbit_bytes', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_setbit_bytes(byte[],uint64,bool)byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_setbit_bytes(byte[],uint64,bool)byte[]'] + returns: MiscellaneousOpsContractReturns['verify_setbit_bytes(byte[],uint64,bool)byte[]'] + }> + & Record<'verify_setbit_uint64(uint64,uint64,bool)uint64' | 'verify_setbit_uint64', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_setbit_uint64(uint64,uint64,bool)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_setbit_uint64(uint64,uint64,bool)uint64'] + returns: MiscellaneousOpsContractReturns['verify_setbit_uint64(uint64,uint64,bool)uint64'] + }> + & Record<'verify_setbyte(byte[],uint64,uint64)byte[]' | 'verify_setbyte', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_setbyte(byte[],uint64,uint64)byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_setbyte(byte[],uint64,uint64)byte[]'] + returns: MiscellaneousOpsContractReturns['verify_setbyte(byte[],uint64,uint64)byte[]'] + }> + & Record<'verify_shl(uint64,uint64)uint64' | 'verify_shl', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_shl(uint64,uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_shl(uint64,uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_shl(uint64,uint64)uint64'] + }> + & Record<'verify_shr(uint64,uint64)uint64' | 'verify_shr', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_shr(uint64,uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_shr(uint64,uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_shr(uint64,uint64)uint64'] + }> + & Record<'verify_sqrt(uint64)uint64' | 'verify_sqrt', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_sqrt(uint64)uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_sqrt(uint64)uint64'] + returns: MiscellaneousOpsContractReturns['verify_sqrt(uint64)uint64'] + }> + & Record<'verify_substring(byte[],uint64,uint64)byte[]' | 'verify_substring', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_substring(byte[],uint64,uint64)byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_substring(byte[],uint64,uint64)byte[]'] + returns: MiscellaneousOpsContractReturns['verify_substring(byte[],uint64,uint64)byte[]'] + }> + & Record<'verify_json_ref_string(byte[],byte[])byte[]' | 'verify_json_ref_string', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_json_ref_string(byte[],byte[])byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_json_ref_string(byte[],byte[])byte[]'] + returns: MiscellaneousOpsContractReturns['verify_json_ref_string(byte[],byte[])byte[]'] + }> + & Record<'verify_json_ref_uint64(byte[],byte[])uint64' | 'verify_json_ref_uint64', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_json_ref_uint64(byte[],byte[])uint64'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_json_ref_uint64(byte[],byte[])uint64'] + returns: MiscellaneousOpsContractReturns['verify_json_ref_uint64(byte[],byte[])uint64'] + }> + & Record<'verify_json_ref_object(byte[],byte[])byte[]' | 'verify_json_ref_object', { + argsObj: MiscellaneousOpsContractArgs['obj']['verify_json_ref_object(byte[],byte[])byte[]'] + argsTuple: MiscellaneousOpsContractArgs['tuple']['verify_json_ref_object(byte[],byte[])byte[]'] + returns: MiscellaneousOpsContractReturns['verify_json_ref_object(byte[],byte[])byte[]'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type MiscellaneousOpsContractSignatures = keyof MiscellaneousOpsContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type MiscellaneousOpsContractNonVoidMethodSignatures = keyof MiscellaneousOpsContractTypes['methods'] extends infer T ? T extends keyof MiscellaneousOpsContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the MiscellaneousOpsContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = MiscellaneousOpsContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the MiscellaneousOpsContract smart contract to the method's return type + */ +export type MethodReturn = MiscellaneousOpsContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type MiscellaneousOpsContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type MiscellaneousOpsContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: MiscellaneousOpsContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the MiscellaneousOpsContract smart contract + */ +export abstract class MiscellaneousOpsContractParamsFactory { + /** + * Constructs a no op call for the verify_addw(uint64,uint64)(uint64,uint64) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAddw(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_addw(uint64,uint64)(uint64,uint64)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_base64_decode_standard(byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBase64DecodeStandard(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_base64_decode_standard(byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_base64_decode_url(byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBase64DecodeUrl(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_base64_decode_url(byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bytes_bitlen(byte[],uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesBitlen(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_bitlen(byte[],uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.padASize], + } + } + /** + * Constructs a no op call for the verify_uint64_bitlen(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Bitlen(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_bitlen(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bsqrt(byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBsqrt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bsqrt(byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_btoi(byte[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBtoi(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_btoi(byte[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_bzero(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBzero(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bzero(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_concat(byte[],byte[],uint64,uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyConcat(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_concat(byte[],byte[],uint64,uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.padASize, params.args.padBSize], + } + } + /** + * Constructs a no op call for the verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyDivmodw(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c, params.args.d], + } + } + /** + * Constructs a no op call for the verify_divw(uint64,uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyDivw(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_divw(uint64,uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_err()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyErr(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_err()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the verify_exp(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyExp(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_exp(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_expw(uint64,uint64)(uint64,uint64) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyExpw(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_expw(uint64,uint64)(uint64,uint64)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_extract(byte[],uint64,uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyExtract(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_extract(byte[],uint64,uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_extract_from_2(byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyExtractFrom_2(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_extract_from_2(byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_extract_uint16(byte[],uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyExtractUint16(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_extract_uint16(byte[],uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_extract_uint32(byte[],uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyExtractUint32(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_extract_uint32(byte[],uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_extract_uint64(byte[],uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyExtractUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_extract_uint64(byte[],uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_getbit_bytes(byte[],uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetbitBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_getbit_bytes(byte[],uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_getbit_uint64(uint64,uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetbitUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_getbit_uint64(uint64,uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_getbyte(byte[],uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetbyte(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_getbyte(byte[],uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_itob(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyItob(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_itob(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_mulw(uint64,uint64)(uint64,uint64) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyMulw(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_mulw(uint64,uint64)(uint64,uint64)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_replace(byte[],uint64,byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyReplace(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_replace(byte[],uint64,byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_select_bytes(byte[],byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySelectBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_select_bytes(byte[],byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_select_uint64(uint64,uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySelectUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_select_uint64(uint64,uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_setbit_bytes(byte[],uint64,bool)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySetbitBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_setbit_bytes(byte[],uint64,bool)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_setbit_uint64(uint64,uint64,bool)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySetbitUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_setbit_uint64(uint64,uint64,bool)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_setbyte(byte[],uint64,uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySetbyte(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_setbyte(byte[],uint64,uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_shl(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyShl(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_shl(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_shr(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyShr(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_shr(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_sqrt(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySqrt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_sqrt(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_substring(byte[],uint64,uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifySubstring(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_substring(byte[],uint64,uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_json_ref_string(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyJsonRefString(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_json_ref_string(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_json_ref_uint64(byte[],byte[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyJsonRefUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_json_ref_uint64(byte[],byte[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_json_ref_object(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyJsonRefObject(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_json_ref_object(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } +} + +/** + * A factory to create and deploy one or more instance of the MiscellaneousOpsContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class MiscellaneousOpsContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `MiscellaneousOpsContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new MiscellaneousOpsContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new MiscellaneousOpsContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the MiscellaneousOpsContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: MiscellaneousOpsContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new MiscellaneousOpsContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the MiscellaneousOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the MiscellaneousOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the MiscellaneousOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new MiscellaneousOpsContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the MiscellaneousOpsContract smart contract + */ +export class MiscellaneousOpsContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `MiscellaneousOpsContractClient` + * + * @param appClient An `AppClient` instance which has been created with the MiscellaneousOpsContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `MiscellaneousOpsContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `MiscellaneousOpsContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new MiscellaneousOpsContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `MiscellaneousOpsContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new MiscellaneousOpsContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the MiscellaneousOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_addw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAddw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyAddw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_base64_decode_standard(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBase64DecodeStandard: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyBase64DecodeStandard(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_base64_decode_url(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBase64DecodeUrl: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyBase64DecodeUrl(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bytes_bitlen(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesBitlen: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyBytesBitlen(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_uint64_bitlen(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Bitlen: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyUint64Bitlen(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bsqrt(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBsqrt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyBsqrt(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_btoi(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBtoi: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyBtoi(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bzero(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBzero: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyBzero(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_concat(byte[],byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyConcat: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyConcat(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyDivmodw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyDivmodw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_divw(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyDivw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyDivw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_err()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyErr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyErr(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_exp(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyExp: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyExp(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_expw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyExpw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyExpw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyExtract: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyExtract(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_from_2(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyExtractFrom_2: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyExtractFrom_2(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint16(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyExtractUint16: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint16(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint32(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyExtractUint32: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint32(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint64(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyExtractUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbit_bytes(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetbitBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyGetbitBytes(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbit_uint64(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetbitUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyGetbitUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbyte(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetbyte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyGetbyte(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_itob(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyItob: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyItob(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_mulw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyMulw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyMulw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_replace(byte[],uint64,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyReplace: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyReplace(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_select_bytes(byte[],byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySelectBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifySelectBytes(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_select_uint64(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySelectUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifySelectUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbit_bytes(byte[],uint64,bool)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySetbitBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifySetbitBytes(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbit_uint64(uint64,uint64,bool)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySetbitUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifySetbitUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbyte(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySetbyte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifySetbyte(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_shl(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyShl: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyShl(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_shr(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyShr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyShr(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_sqrt(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySqrt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifySqrt(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_substring(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifySubstring: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifySubstring(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_string(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyJsonRefString: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefString(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_uint64(byte[],byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyJsonRefUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_object(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyJsonRefObject: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefObject(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the MiscellaneousOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_addw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAddw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyAddw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_base64_decode_standard(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBase64DecodeStandard: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyBase64DecodeStandard(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_base64_decode_url(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBase64DecodeUrl: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyBase64DecodeUrl(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bytes_bitlen(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesBitlen: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyBytesBitlen(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_uint64_bitlen(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Bitlen: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyUint64Bitlen(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bsqrt(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBsqrt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyBsqrt(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_btoi(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBtoi: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyBtoi(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bzero(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBzero: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyBzero(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_concat(byte[],byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyConcat: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyConcat(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyDivmodw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyDivmodw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_divw(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyDivw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyDivw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_err()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyErr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyErr(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_exp(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyExp: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyExp(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_expw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyExpw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyExpw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyExtract: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyExtract(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_from_2(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyExtractFrom_2: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyExtractFrom_2(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint16(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyExtractUint16: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint16(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint32(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyExtractUint32: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint32(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint64(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyExtractUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbit_bytes(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetbitBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyGetbitBytes(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbit_uint64(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetbitUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyGetbitUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbyte(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetbyte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyGetbyte(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_itob(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyItob: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyItob(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_mulw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyMulw: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyMulw(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_replace(byte[],uint64,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyReplace: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyReplace(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_select_bytes(byte[],byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySelectBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifySelectBytes(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_select_uint64(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySelectUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifySelectUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbit_bytes(byte[],uint64,bool)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySetbitBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifySetbitBytes(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbit_uint64(uint64,uint64,bool)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySetbitUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifySetbitUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbyte(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySetbyte: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifySetbyte(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_shl(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyShl: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyShl(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_shr(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyShr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyShr(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_sqrt(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySqrt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifySqrt(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_substring(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifySubstring: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifySubstring(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_string(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyJsonRefString: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefString(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_uint64(byte[],byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyJsonRefUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefUint64(params)) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_object(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyJsonRefObject: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefObject(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the MiscellaneousOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_addw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAddw: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyAddw(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_addw(uint64,uint64)(uint64,uint64)'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_base64_decode_standard(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBase64DecodeStandard: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyBase64DecodeStandard(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_base64_decode_standard(byte[])byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_base64_decode_url(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBase64DecodeUrl: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyBase64DecodeUrl(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_base64_decode_url(byte[])byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bytes_bitlen(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesBitlen: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyBytesBitlen(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_bytes_bitlen(byte[],uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_uint64_bitlen(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Bitlen: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyUint64Bitlen(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_uint64_bitlen(uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bsqrt(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBsqrt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyBsqrt(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_bsqrt(byte[])byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_btoi(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBtoi: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyBtoi(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_btoi(byte[])uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_bzero(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBzero: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyBzero(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_bzero(uint64)byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_concat(byte[],byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyConcat: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyConcat(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_concat(byte[],byte[],uint64,uint64)byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyDivmodw: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyDivmodw(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_divw(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyDivw: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyDivw(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_divw(uint64,uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_err()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyErr: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyErr(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_err()void'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_exp(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyExp: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyExp(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_exp(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_expw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyExpw: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyExpw(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_expw(uint64,uint64)(uint64,uint64)'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyExtract: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyExtract(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_extract(byte[],uint64,uint64)byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_from_2(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyExtractFrom_2: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyExtractFrom_2(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_extract_from_2(byte[])byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint16(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyExtractUint16: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint16(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_extract_uint16(byte[],uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint32(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyExtractUint32: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint32(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_extract_uint32(byte[],uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_extract_uint64(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyExtractUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyExtractUint64(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_extract_uint64(byte[],uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbit_bytes(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetbitBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyGetbitBytes(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_getbit_bytes(byte[],uint64)bool'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbit_uint64(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetbitUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyGetbitUint64(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_getbit_uint64(uint64,uint64)bool'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_getbyte(byte[],uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetbyte: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyGetbyte(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_getbyte(byte[],uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_itob(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyItob: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyItob(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_itob(uint64)byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_mulw(uint64,uint64)(uint64,uint64)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyMulw: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyMulw(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_mulw(uint64,uint64)(uint64,uint64)'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_replace(byte[],uint64,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyReplace: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyReplace(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_replace(byte[],uint64,byte[])byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_select_bytes(byte[],byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySelectBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifySelectBytes(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_select_bytes(byte[],byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_select_uint64(uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySelectUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifySelectUint64(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_select_uint64(uint64,uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbit_bytes(byte[],uint64,bool)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySetbitBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifySetbitBytes(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_setbit_bytes(byte[],uint64,bool)byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbit_uint64(uint64,uint64,bool)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySetbitUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifySetbitUint64(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_setbit_uint64(uint64,uint64,bool)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_setbyte(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySetbyte: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifySetbyte(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_setbyte(byte[],uint64,uint64)byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_shl(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyShl: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyShl(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_shl(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_shr(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyShr: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyShr(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_shr(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_sqrt(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySqrt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifySqrt(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_sqrt(uint64)uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_substring(byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifySubstring: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifySubstring(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_substring(byte[],uint64,uint64)byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_string(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyJsonRefString: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefString(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_json_ref_string(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_uint64(byte[],byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyJsonRefUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefUint64(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_json_ref_uint64(byte[],byte[])uint64'])} + }, + + /** + * Makes a call to the MiscellaneousOpsContract smart contract using the `verify_json_ref_object(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyJsonRefObject: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(MiscellaneousOpsContractParamsFactory.verifyJsonRefObject(params)) + return {...result, return: result.return as unknown as (undefined | MiscellaneousOpsContractReturns['verify_json_ref_object(byte[],byte[])byte[]'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new MiscellaneousOpsContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current MiscellaneousOpsContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): MiscellaneousOpsContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_addw(uint64,uint64)(uint64,uint64) method call against the MiscellaneousOpsContract contract + */ + verifyAddw(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAddw(params))) + return this + }, + /** + * Add a verify_base64_decode_standard(byte[])byte[] method call against the MiscellaneousOpsContract contract + */ + verifyBase64DecodeStandard(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBase64DecodeStandard(params))) + return this + }, + /** + * Add a verify_base64_decode_url(byte[])byte[] method call against the MiscellaneousOpsContract contract + */ + verifyBase64DecodeUrl(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBase64DecodeUrl(params))) + return this + }, + /** + * Add a verify_bytes_bitlen(byte[],uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyBytesBitlen(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesBitlen(params))) + return this + }, + /** + * Add a verify_uint64_bitlen(uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyUint64Bitlen(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Bitlen(params))) + return this + }, + /** + * Add a verify_bsqrt(byte[])byte[] method call against the MiscellaneousOpsContract contract + */ + verifyBsqrt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBsqrt(params))) + return this + }, + /** + * Add a verify_btoi(byte[])uint64 method call against the MiscellaneousOpsContract contract + */ + verifyBtoi(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBtoi(params))) + return this + }, + /** + * Add a verify_bzero(uint64)byte[] method call against the MiscellaneousOpsContract contract + */ + verifyBzero(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBzero(params))) + return this + }, + /** + * Add a verify_concat(byte[],byte[],uint64,uint64)byte[] method call against the MiscellaneousOpsContract contract + */ + verifyConcat(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyConcat(params))) + return this + }, + /** + * Add a verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64) method call against the MiscellaneousOpsContract contract + */ + verifyDivmodw(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyDivmodw(params))) + return this + }, + /** + * Add a verify_divw(uint64,uint64,uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyDivw(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyDivw(params))) + return this + }, + /** + * Add a verify_err()void method call against the MiscellaneousOpsContract contract + */ + verifyErr(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyErr(params))) + return this + }, + /** + * Add a verify_exp(uint64,uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyExp(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyExp(params))) + return this + }, + /** + * Add a verify_expw(uint64,uint64)(uint64,uint64) method call against the MiscellaneousOpsContract contract + */ + verifyExpw(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyExpw(params))) + return this + }, + /** + * Add a verify_extract(byte[],uint64,uint64)byte[] method call against the MiscellaneousOpsContract contract + */ + verifyExtract(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyExtract(params))) + return this + }, + /** + * Add a verify_extract_from_2(byte[])byte[] method call against the MiscellaneousOpsContract contract + */ + verifyExtractFrom_2(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyExtractFrom_2(params))) + return this + }, + /** + * Add a verify_extract_uint16(byte[],uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyExtractUint16(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyExtractUint16(params))) + return this + }, + /** + * Add a verify_extract_uint32(byte[],uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyExtractUint32(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyExtractUint32(params))) + return this + }, + /** + * Add a verify_extract_uint64(byte[],uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyExtractUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyExtractUint64(params))) + return this + }, + /** + * Add a verify_getbit_bytes(byte[],uint64)bool method call against the MiscellaneousOpsContract contract + */ + verifyGetbitBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetbitBytes(params))) + return this + }, + /** + * Add a verify_getbit_uint64(uint64,uint64)bool method call against the MiscellaneousOpsContract contract + */ + verifyGetbitUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetbitUint64(params))) + return this + }, + /** + * Add a verify_getbyte(byte[],uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyGetbyte(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetbyte(params))) + return this + }, + /** + * Add a verify_itob(uint64)byte[] method call against the MiscellaneousOpsContract contract + */ + verifyItob(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyItob(params))) + return this + }, + /** + * Add a verify_mulw(uint64,uint64)(uint64,uint64) method call against the MiscellaneousOpsContract contract + */ + verifyMulw(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyMulw(params))) + return this + }, + /** + * Add a verify_replace(byte[],uint64,byte[])byte[] method call against the MiscellaneousOpsContract contract + */ + verifyReplace(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyReplace(params))) + return this + }, + /** + * Add a verify_select_bytes(byte[],byte[],uint64)byte[] method call against the MiscellaneousOpsContract contract + */ + verifySelectBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySelectBytes(params))) + return this + }, + /** + * Add a verify_select_uint64(uint64,uint64,uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifySelectUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySelectUint64(params))) + return this + }, + /** + * Add a verify_setbit_bytes(byte[],uint64,bool)byte[] method call against the MiscellaneousOpsContract contract + */ + verifySetbitBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySetbitBytes(params))) + return this + }, + /** + * Add a verify_setbit_uint64(uint64,uint64,bool)uint64 method call against the MiscellaneousOpsContract contract + */ + verifySetbitUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySetbitUint64(params))) + return this + }, + /** + * Add a verify_setbyte(byte[],uint64,uint64)byte[] method call against the MiscellaneousOpsContract contract + */ + verifySetbyte(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySetbyte(params))) + return this + }, + /** + * Add a verify_shl(uint64,uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyShl(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyShl(params))) + return this + }, + /** + * Add a verify_shr(uint64,uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifyShr(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyShr(params))) + return this + }, + /** + * Add a verify_sqrt(uint64)uint64 method call against the MiscellaneousOpsContract contract + */ + verifySqrt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySqrt(params))) + return this + }, + /** + * Add a verify_substring(byte[],uint64,uint64)byte[] method call against the MiscellaneousOpsContract contract + */ + verifySubstring(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifySubstring(params))) + return this + }, + /** + * Add a verify_json_ref_string(byte[],byte[])byte[] method call against the MiscellaneousOpsContract contract + */ + verifyJsonRefString(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyJsonRefString(params))) + return this + }, + /** + * Add a verify_json_ref_uint64(byte[],byte[])uint64 method call against the MiscellaneousOpsContract contract + */ + verifyJsonRefUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyJsonRefUint64(params))) + return this + }, + /** + * Add a verify_json_ref_object(byte[],byte[])byte[] method call against the MiscellaneousOpsContract contract + */ + verifyJsonRefObject(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyJsonRefObject(params))) + return this + }, + /** + * Add a clear state call to the MiscellaneousOpsContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as MiscellaneousOpsContractComposer + } +} +export type MiscellaneousOpsContractComposer = { + /** + * Calls the verify_addw(uint64,uint64)(uint64,uint64) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAddw(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_addw(uint64,uint64)(uint64,uint64)'] | undefined]> + + /** + * Calls the verify_base64_decode_standard(byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBase64DecodeStandard(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_base64_decode_standard(byte[])byte[]'] | undefined]> + + /** + * Calls the verify_base64_decode_url(byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBase64DecodeUrl(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_base64_decode_url(byte[])byte[]'] | undefined]> + + /** + * Calls the verify_bytes_bitlen(byte[],uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesBitlen(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_bytes_bitlen(byte[],uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_bitlen(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Bitlen(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_uint64_bitlen(uint64)uint64'] | undefined]> + + /** + * Calls the verify_bsqrt(byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBsqrt(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_bsqrt(byte[])byte[]'] | undefined]> + + /** + * Calls the verify_btoi(byte[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBtoi(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_btoi(byte[])uint64'] | undefined]> + + /** + * Calls the verify_bzero(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBzero(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_bzero(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_concat(byte[],byte[],uint64,uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyConcat(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_concat(byte[],byte[],uint64,uint64)byte[]'] | undefined]> + + /** + * Calls the verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyDivmodw(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)'] | undefined]> + + /** + * Calls the verify_divw(uint64,uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyDivw(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_divw(uint64,uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_err()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyErr(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_err()void'] | undefined]> + + /** + * Calls the verify_exp(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyExp(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_exp(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_expw(uint64,uint64)(uint64,uint64) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyExpw(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_expw(uint64,uint64)(uint64,uint64)'] | undefined]> + + /** + * Calls the verify_extract(byte[],uint64,uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyExtract(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_extract(byte[],uint64,uint64)byte[]'] | undefined]> + + /** + * Calls the verify_extract_from_2(byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyExtractFrom_2(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_extract_from_2(byte[])byte[]'] | undefined]> + + /** + * Calls the verify_extract_uint16(byte[],uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyExtractUint16(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_extract_uint16(byte[],uint64)uint64'] | undefined]> + + /** + * Calls the verify_extract_uint32(byte[],uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyExtractUint32(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_extract_uint32(byte[],uint64)uint64'] | undefined]> + + /** + * Calls the verify_extract_uint64(byte[],uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyExtractUint64(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_extract_uint64(byte[],uint64)uint64'] | undefined]> + + /** + * Calls the verify_getbit_bytes(byte[],uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetbitBytes(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_getbit_bytes(byte[],uint64)bool'] | undefined]> + + /** + * Calls the verify_getbit_uint64(uint64,uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetbitUint64(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_getbit_uint64(uint64,uint64)bool'] | undefined]> + + /** + * Calls the verify_getbyte(byte[],uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetbyte(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_getbyte(byte[],uint64)uint64'] | undefined]> + + /** + * Calls the verify_itob(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyItob(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_itob(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_mulw(uint64,uint64)(uint64,uint64) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyMulw(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_mulw(uint64,uint64)(uint64,uint64)'] | undefined]> + + /** + * Calls the verify_replace(byte[],uint64,byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyReplace(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_replace(byte[],uint64,byte[])byte[]'] | undefined]> + + /** + * Calls the verify_select_bytes(byte[],byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySelectBytes(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_select_bytes(byte[],byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_select_uint64(uint64,uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySelectUint64(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_select_uint64(uint64,uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_setbit_bytes(byte[],uint64,bool)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySetbitBytes(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_setbit_bytes(byte[],uint64,bool)byte[]'] | undefined]> + + /** + * Calls the verify_setbit_uint64(uint64,uint64,bool)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySetbitUint64(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_setbit_uint64(uint64,uint64,bool)uint64'] | undefined]> + + /** + * Calls the verify_setbyte(byte[],uint64,uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySetbyte(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_setbyte(byte[],uint64,uint64)byte[]'] | undefined]> + + /** + * Calls the verify_shl(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyShl(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_shl(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_shr(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyShr(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_shr(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_sqrt(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySqrt(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_sqrt(uint64)uint64'] | undefined]> + + /** + * Calls the verify_substring(byte[],uint64,uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifySubstring(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_substring(byte[],uint64,uint64)byte[]'] | undefined]> + + /** + * Calls the verify_json_ref_string(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyJsonRefString(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_json_ref_string(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_json_ref_uint64(byte[],byte[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyJsonRefUint64(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_json_ref_uint64(byte[],byte[])uint64'] | undefined]> + + /** + * Calls the verify_json_ref_object(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyJsonRefObject(params?: CallParams): MiscellaneousOpsContractComposer<[...TReturns, MiscellaneousOpsContractReturns['verify_json_ref_object(byte[],byte[])byte[]'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the MiscellaneousOpsContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): MiscellaneousOpsContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): MiscellaneousOpsContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type MiscellaneousOpsContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/PrimitiveOpsContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/PrimitiveOpsContract.ts new file mode 100644 index 0000000..5ff671b --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/PrimitiveOpsContract.ts @@ -0,0 +1,4701 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"PrimitiveOpsContract","structs":{},"methods":[{"name":"verify_uint64_init","args":[{"type":"byte[]","name":"raw_value"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_add","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_sub","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_mul","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_div","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_mod","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_and","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_or","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_xor","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_not","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_lshift","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_rshift","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_pow","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_eq","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_ne","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_lt","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_le","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_gt","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_uint64_ge","args":[{"type":"uint64","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_init","args":[{"type":"uint64","name":"raw_value"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_add","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"},{"type":"uint64","name":"pad_a_size"},{"type":"uint64","name":"pad_b_size"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_eq","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_ne","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_and","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_or","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_xor","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_bytes_not","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"pad_size"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_add","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_add_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_sub","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_sub_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_mul","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_mul_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_div","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_div_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_mod","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_mod_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_and","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_and_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_or","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_or_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_xor","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_xor_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_eq","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_eq_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_ne","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_ne_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_lt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_lt_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_le","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_le_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_gt","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_gt_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_ge","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_biguint_ge_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_init","args":[{"type":"string","name":"a"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_startswith","args":[{"type":"string","name":"a"},{"type":"string","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_endswith","args":[{"type":"string","name":"a"},{"type":"string","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_string_join","args":[{"type":"string","name":"a"},{"type":"string","name":"b"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_log","args":[{"type":"string","name":"a"},{"type":"uint64","name":"b"},{"type":"byte[]","name":"c"},{"type":"byte[]","name":"d"},{"type":"bool","name":"e"},{"type":"string","name":"f"},{"type":"uint64","name":"g"},{"type":"uint256","name":"h"},{"type":"ufixed32x8","name":"i"},{"type":"ufixed256x16","name":"j"},{"type":"byte[]","name":"k"},{"type":"byte[]","name":"m"},{"type":"byte[]","name":"n"},{"type":"byte[5]","name":"o"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75 0x00 "-" 0x151f7c750020
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@67
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x725c692b 0x17314559 0x53f34893 0x88c8b269 0xa464b7ab 0x9c8b11b8 0x6f40654e 0xec9a2974 0xc793708f 0x7ddb7499 0xa21c443d 0x6e7fb212 0xb007fcb0 0x2ebc20d4 0xb0954b66 0xdd140aef 0xace474da 0xba694990 0x6db581c0 0x91c8db89 0xdbe77158 0x9a0f22e1 0x64033d37 0x2a7237c5 0xe3a94458 0x42f87f7d 0x2b5542a4 0x9be2fbe9 0x1cd92515 0x64e1705c 0xf1271c50 0x2ab63b70 0x834bb7d2 0x531620d7 0x3fb9e769 0xfa8db0bc 0xa72ea485 0xb7b0ba19 0x74460c42 0xab320738 0x52ad4654 0x10156399 0x0f075957 0xbd843dff 0xb377d381 0x89767265 0x456b4b23 0x33d1b88c 0x6bf973ea 0x67cd6bb2 0x3f58805a 0x1e130039 0x509dc91d 0xa564a202 0x23650763 0xf8c8f8d5 0x23faf7a4 0x7d0afe15 0x48581adf 0x3daef9cd // method "verify_uint64_init(byte[])uint64", method "verify_uint64_add(uint64,uint64)uint64", method "verify_uint64_sub(uint64,uint64)uint64", method "verify_uint64_mul(uint64,uint64)uint64", method "verify_uint64_div(uint64,uint64)uint64", method "verify_uint64_mod(uint64,uint64)uint64", method "verify_uint64_and(uint64,uint64)uint64", method "verify_uint64_or(uint64,uint64)uint64", method "verify_uint64_xor(uint64,uint64)uint64", method "verify_uint64_not(uint64)uint64", method "verify_uint64_lshift(uint64,uint64)uint64", method "verify_uint64_rshift(uint64,uint64)uint64", method "verify_uint64_pow(uint64,uint64)uint64", method "verify_uint64_eq(uint64,uint64)bool", method "verify_uint64_ne(uint64,uint64)bool", method "verify_uint64_lt(uint64,uint64)bool", method "verify_uint64_le(uint64,uint64)bool", method "verify_uint64_gt(uint64,uint64)bool", method "verify_uint64_ge(uint64,uint64)bool", method "verify_bytes_init(uint64)byte[]", method "verify_bytes_add(byte[],byte[],uint64,uint64)byte[]", method "verify_bytes_eq(byte[],byte[])bool", method "verify_bytes_ne(byte[],byte[])bool", method "verify_bytes_and(byte[],byte[])byte[]", method "verify_bytes_or(byte[],byte[])byte[]", method "verify_bytes_xor(byte[],byte[])byte[]", method "verify_bytes_not(byte[],uint64)byte[]", method "verify_biguint_add(byte[],byte[])byte[]", method "verify_biguint_add_uint64(byte[],uint64)byte[]", method "verify_biguint_sub(byte[],byte[])byte[]", method "verify_biguint_sub_uint64(byte[],uint64)byte[]", method "verify_biguint_mul(byte[],byte[])byte[]", method "verify_biguint_mul_uint64(byte[],uint64)byte[]", method "verify_biguint_div(byte[],byte[])byte[]", method "verify_biguint_div_uint64(byte[],uint64)byte[]", method "verify_biguint_mod(byte[],byte[])byte[]", method "verify_biguint_mod_uint64(byte[],uint64)byte[]", method "verify_biguint_and(byte[],byte[])byte[]", method "verify_biguint_and_uint64(byte[],uint64)byte[]", method "verify_biguint_or(byte[],byte[])byte[]", method "verify_biguint_or_uint64(byte[],uint64)byte[]", method "verify_biguint_xor(byte[],byte[])byte[]", method "verify_biguint_xor_uint64(byte[],uint64)byte[]", method "verify_biguint_eq(byte[],byte[])bool", method "verify_biguint_eq_uint64(byte[],uint64)bool", method "verify_biguint_ne(byte[],byte[])bool", method "verify_biguint_ne_uint64(byte[],uint64)bool", method "verify_biguint_lt(byte[],byte[])bool", method "verify_biguint_lt_uint64(byte[],uint64)bool", method "verify_biguint_le(byte[],byte[])bool", method "verify_biguint_le_uint64(byte[],uint64)bool", method "verify_biguint_gt(byte[],byte[])bool", method "verify_biguint_gt_uint64(byte[],uint64)bool", method "verify_biguint_ge(byte[],byte[])bool", method "verify_biguint_ge_uint64(byte[],uint64)bool", method "verify_string_init(string)string", method "verify_string_startswith(string,string)bool", method "verify_string_endswith(string,string)bool", method "verify_string_join(string,string)string", method "verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void"
    txna ApplicationArgs 0
    match verify_uint64_init verify_uint64_add verify_uint64_sub verify_uint64_mul verify_uint64_div verify_uint64_mod verify_uint64_and verify_uint64_or verify_uint64_xor verify_uint64_not verify_uint64_lshift verify_uint64_rshift verify_uint64_pow verify_uint64_eq verify_uint64_ne verify_uint64_lt verify_uint64_le verify_uint64_gt verify_uint64_ge verify_bytes_init verify_bytes_add verify_bytes_eq verify_bytes_ne verify_bytes_and verify_bytes_or verify_bytes_xor verify_bytes_not verify_biguint_add verify_biguint_add_uint64 verify_biguint_sub verify_biguint_sub_uint64 verify_biguint_mul verify_biguint_mul_uint64 verify_biguint_div verify_biguint_div_uint64 verify_biguint_mod verify_biguint_mod_uint64 verify_biguint_and verify_biguint_and_uint64 verify_biguint_or verify_biguint_or_uint64 verify_biguint_xor verify_biguint_xor_uint64 verify_biguint_eq verify_biguint_eq_uint64 verify_biguint_ne verify_biguint_ne_uint64 verify_biguint_lt verify_biguint_lt_uint64 verify_biguint_le verify_biguint_le_uint64 verify_biguint_gt verify_biguint_gt_uint64 verify_biguint_ge verify_biguint_ge_uint64 verify_string_init verify_string_startswith verify_string_endswith verify_string_join verify_log
    err

main___algopy_default_create@67:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_init[routing]() -> void:
verify_uint64_init:
    // tests/artifacts/PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:9
    // result = op.btoi(raw_value)
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_add[routing]() -> void:
verify_uint64_add:
    // tests/artifacts/PrimitiveOps/contract.py:12
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:14
    // result = a + b
    +
    // tests/artifacts/PrimitiveOps/contract.py:12
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_sub[routing]() -> void:
verify_uint64_sub:
    // tests/artifacts/PrimitiveOps/contract.py:17
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:19
    // result = a - b
    -
    // tests/artifacts/PrimitiveOps/contract.py:17
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_mul[routing]() -> void:
verify_uint64_mul:
    // tests/artifacts/PrimitiveOps/contract.py:22
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:24
    // result = a * b
    *
    // tests/artifacts/PrimitiveOps/contract.py:22
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_div[routing]() -> void:
verify_uint64_div:
    // tests/artifacts/PrimitiveOps/contract.py:27
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:29
    // result = a // b
    /
    // tests/artifacts/PrimitiveOps/contract.py:27
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_mod[routing]() -> void:
verify_uint64_mod:
    // tests/artifacts/PrimitiveOps/contract.py:32
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:34
    // result = a % b
    %
    // tests/artifacts/PrimitiveOps/contract.py:32
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_and[routing]() -> void:
verify_uint64_and:
    // tests/artifacts/PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:39
    // result = a & b
    &
    // tests/artifacts/PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_or[routing]() -> void:
verify_uint64_or:
    // tests/artifacts/PrimitiveOps/contract.py:42
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:44
    // result = a | b
    |
    // tests/artifacts/PrimitiveOps/contract.py:42
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_xor[routing]() -> void:
verify_uint64_xor:
    // tests/artifacts/PrimitiveOps/contract.py:47
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:49
    // result = a ^ b
    ^
    // tests/artifacts/PrimitiveOps/contract.py:47
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_not[routing]() -> void:
verify_uint64_not:
    // tests/artifacts/PrimitiveOps/contract.py:52
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:54
    // result = ~a
    ~
    // tests/artifacts/PrimitiveOps/contract.py:52
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_lshift[routing]() -> void:
verify_uint64_lshift:
    // tests/artifacts/PrimitiveOps/contract.py:57
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:59
    // result = a << b
    shl
    // tests/artifacts/PrimitiveOps/contract.py:57
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_rshift[routing]() -> void:
verify_uint64_rshift:
    // tests/artifacts/PrimitiveOps/contract.py:62
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:64
    // result = a >> b
    shr
    // tests/artifacts/PrimitiveOps/contract.py:62
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_pow[routing]() -> void:
verify_uint64_pow:
    // tests/artifacts/PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:69
    // result = a**b
    exp
    // tests/artifacts/PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_eq[routing]() -> void:
verify_uint64_eq:
    // tests/artifacts/PrimitiveOps/contract.py:72
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:74
    // result = a == b
    ==
    // tests/artifacts/PrimitiveOps/contract.py:72
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_ne[routing]() -> void:
verify_uint64_ne:
    // tests/artifacts/PrimitiveOps/contract.py:77
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:79
    // result = a != b
    !=
    // tests/artifacts/PrimitiveOps/contract.py:77
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_lt[routing]() -> void:
verify_uint64_lt:
    // tests/artifacts/PrimitiveOps/contract.py:82
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:84
    // result = a < b
    <
    // tests/artifacts/PrimitiveOps/contract.py:82
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_le[routing]() -> void:
verify_uint64_le:
    // tests/artifacts/PrimitiveOps/contract.py:87
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:89
    // result = a <= b
    <=
    // tests/artifacts/PrimitiveOps/contract.py:87
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_gt[routing]() -> void:
verify_uint64_gt:
    // tests/artifacts/PrimitiveOps/contract.py:92
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:94
    // result = a > b
    >
    // tests/artifacts/PrimitiveOps/contract.py:92
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_ge[routing]() -> void:
verify_uint64_ge:
    // tests/artifacts/PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:99
    // result = a >= b
    >=
    // tests/artifacts/PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_init[routing]() -> void:
verify_bytes_init:
    // tests/artifacts/PrimitiveOps/contract.py:102
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:104
    // result = op.itob(raw_value)
    itob
    // tests/artifacts/PrimitiveOps/contract.py:102
    // @arc4.abimethod()
    pushbytes 0x151f7c750008
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_add[routing]() -> void:
verify_bytes_add:
    // tests/artifacts/PrimitiveOps/contract.py:107
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:111
    // a = op.bzero(pad_a_size) + a
    swap
    bzero
    uncover 3
    concat
    // tests/artifacts/PrimitiveOps/contract.py:112
    // b = op.bzero(pad_b_size) + b
    swap
    bzero
    uncover 2
    concat
    // tests/artifacts/PrimitiveOps/contract.py:113
    // result = a + b
    concat
    // tests/artifacts/PrimitiveOps/contract.py:114
    // result = op.sha256(result)
    sha256
    // tests/artifacts/PrimitiveOps/contract.py:107
    // @arc4.abimethod()
    bytec_3 // 0x151f7c750020
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_eq[routing]() -> void:
verify_bytes_eq:
    // tests/artifacts/PrimitiveOps/contract.py:117
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:119
    // result = a == b
    ==
    // tests/artifacts/PrimitiveOps/contract.py:117
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_ne[routing]() -> void:
verify_bytes_ne:
    // tests/artifacts/PrimitiveOps/contract.py:122
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:124
    // result = a != b
    !=
    // tests/artifacts/PrimitiveOps/contract.py:122
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_and[routing]() -> void:
verify_bytes_and:
    // tests/artifacts/PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:129
    // result = a & b
    b&
    // tests/artifacts/PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_or[routing]() -> void:
verify_bytes_or:
    // tests/artifacts/PrimitiveOps/contract.py:132
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:134
    // result = a | b
    b|
    // tests/artifacts/PrimitiveOps/contract.py:132
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_xor[routing]() -> void:
verify_bytes_xor:
    // tests/artifacts/PrimitiveOps/contract.py:137
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:139
    // result = a ^ b
    b^
    // tests/artifacts/PrimitiveOps/contract.py:137
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_not[routing]() -> void:
verify_bytes_not:
    // tests/artifacts/PrimitiveOps/contract.py:142
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:144
    // a = op.bzero(pad_size) + a
    bzero
    swap
    concat
    // tests/artifacts/PrimitiveOps/contract.py:145
    // result = ~a
    b~
    // tests/artifacts/PrimitiveOps/contract.py:146
    // result = op.sha256(result)
    sha256
    // tests/artifacts/PrimitiveOps/contract.py:142
    // @arc4.abimethod()
    bytec_3 // 0x151f7c750020
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_add[routing]() -> void:
verify_biguint_add:
    // tests/artifacts/PrimitiveOps/contract.py:149
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:153
    // result = a_biguint + b_biguint
    b+
    // tests/artifacts/PrimitiveOps/contract.py:149
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_add_uint64[routing]() -> void:
verify_biguint_add_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:159
    // result = a_biguint + b
    itob
    b+
    // tests/artifacts/PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_sub[routing]() -> void:
verify_biguint_sub:
    // tests/artifacts/PrimitiveOps/contract.py:162
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:166
    // result = a_biguint - b_biguint
    b-
    // tests/artifacts/PrimitiveOps/contract.py:162
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_sub_uint64[routing]() -> void:
verify_biguint_sub_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:172
    // result = a_biguint - b
    itob
    b-
    // tests/artifacts/PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mul[routing]() -> void:
verify_biguint_mul:
    // tests/artifacts/PrimitiveOps/contract.py:175
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:179
    // result = a_biguint * b_biguint
    b*
    // tests/artifacts/PrimitiveOps/contract.py:175
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mul_uint64[routing]() -> void:
verify_biguint_mul_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:182
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:185
    // result = a_biguint * b
    itob
    b*
    // tests/artifacts/PrimitiveOps/contract.py:182
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_div[routing]() -> void:
verify_biguint_div:
    // tests/artifacts/PrimitiveOps/contract.py:188
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:192
    // result = a_biguint // b_biguint
    b/
    // tests/artifacts/PrimitiveOps/contract.py:188
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_div_uint64[routing]() -> void:
verify_biguint_div_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:198
    // result = a_biguint // b
    itob
    b/
    // tests/artifacts/PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mod[routing]() -> void:
verify_biguint_mod:
    // tests/artifacts/PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:205
    // result = a_biguint % b_biguint
    b%
    // tests/artifacts/PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mod_uint64[routing]() -> void:
verify_biguint_mod_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:208
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:211
    // result = a_biguint % b
    itob
    b%
    // tests/artifacts/PrimitiveOps/contract.py:208
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_and[routing]() -> void:
verify_biguint_and:
    // tests/artifacts/PrimitiveOps/contract.py:214
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:218
    // result = a_biguint & b_biguint
    b&
    // tests/artifacts/PrimitiveOps/contract.py:214
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_and_uint64[routing]() -> void:
verify_biguint_and_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:221
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:224
    // result = a_biguint & b
    itob
    b&
    // tests/artifacts/PrimitiveOps/contract.py:221
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_or[routing]() -> void:
verify_biguint_or:
    // tests/artifacts/PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:231
    // result = a_biguint | b_biguint
    b|
    // tests/artifacts/PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_or_uint64[routing]() -> void:
verify_biguint_or_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:234
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:237
    // result = a_biguint | b
    itob
    b|
    // tests/artifacts/PrimitiveOps/contract.py:234
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_xor[routing]() -> void:
verify_biguint_xor:
    // tests/artifacts/PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:244
    // result = a_biguint ^ b_biguint
    b^
    // tests/artifacts/PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_xor_uint64[routing]() -> void:
verify_biguint_xor_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:247
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:250
    // result = a_biguint ^ b
    itob
    b^
    // tests/artifacts/PrimitiveOps/contract.py:247
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_eq[routing]() -> void:
verify_biguint_eq:
    // tests/artifacts/PrimitiveOps/contract.py:253
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:257
    // result = a_biguint == b_biguint
    b==
    // tests/artifacts/PrimitiveOps/contract.py:253
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_eq_uint64[routing]() -> void:
verify_biguint_eq_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:260
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:263
    // result = a_biguint == b
    itob
    b==
    // tests/artifacts/PrimitiveOps/contract.py:260
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ne[routing]() -> void:
verify_biguint_ne:
    // tests/artifacts/PrimitiveOps/contract.py:266
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:270
    // result = a_biguint != b_biguint
    b!=
    // tests/artifacts/PrimitiveOps/contract.py:266
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ne_uint64[routing]() -> void:
verify_biguint_ne_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:273
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:276
    // result = a_biguint != b
    itob
    b!=
    // tests/artifacts/PrimitiveOps/contract.py:273
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_lt[routing]() -> void:
verify_biguint_lt:
    // tests/artifacts/PrimitiveOps/contract.py:279
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:283
    // result = a_biguint < b_biguint
    b<
    // tests/artifacts/PrimitiveOps/contract.py:279
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_lt_uint64[routing]() -> void:
verify_biguint_lt_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:286
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:289
    // result = a_biguint < b
    itob
    b<
    // tests/artifacts/PrimitiveOps/contract.py:286
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_le[routing]() -> void:
verify_biguint_le:
    // tests/artifacts/PrimitiveOps/contract.py:292
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:296
    // result = a_biguint <= b_biguint
    b<=
    // tests/artifacts/PrimitiveOps/contract.py:292
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_le_uint64[routing]() -> void:
verify_biguint_le_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:299
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:302
    // result = a_biguint <= b
    itob
    b<=
    // tests/artifacts/PrimitiveOps/contract.py:299
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_gt[routing]() -> void:
verify_biguint_gt:
    // tests/artifacts/PrimitiveOps/contract.py:305
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:309
    // result = a_biguint > b_biguint
    b>
    // tests/artifacts/PrimitiveOps/contract.py:305
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_gt_uint64[routing]() -> void:
verify_biguint_gt_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:312
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:315
    // result = a_biguint > b
    itob
    b>
    // tests/artifacts/PrimitiveOps/contract.py:312
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ge[routing]() -> void:
verify_biguint_ge:
    // tests/artifacts/PrimitiveOps/contract.py:318
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:322
    // result = a_biguint >= b_biguint
    b>=
    // tests/artifacts/PrimitiveOps/contract.py:318
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ge_uint64[routing]() -> void:
verify_biguint_ge_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:325
    // @arc4.abimethod()
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:328
    // result = a_biguint >= b
    itob
    b>=
    // tests/artifacts/PrimitiveOps/contract.py:325
    // @arc4.abimethod()
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_init[routing]() -> void:
verify_string_init:
    // tests/artifacts/PrimitiveOps/contract.py:331
    // @arc4.abimethod
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:333
    // result = String("Hello, ") + a
    pushbytes "Hello, "
    swap
    concat
    // tests/artifacts/PrimitiveOps/contract.py:331
    // @arc4.abimethod
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_startswith[routing]() -> void:
verify_string_startswith:
    // tests/artifacts/PrimitiveOps/contract.py:336
    // @arc4.abimethod
    txna ApplicationArgs 1
    extract 2 0
    dup
    txna ApplicationArgs 2
    extract 2 0
    dup
    cover 2
    // tests/artifacts/PrimitiveOps/contract.py:338
    // result = a.startswith(b)
    len
    dup
    uncover 2
    len
    >
    bz verify_string_startswith_ternary_false@3
    intc_1 // 0

verify_string_startswith_ternary_merge@4:
    // tests/artifacts/PrimitiveOps/contract.py:336
    // @arc4.abimethod
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

verify_string_startswith_ternary_false@3:
    // tests/artifacts/PrimitiveOps/contract.py:338
    // result = a.startswith(b)
    dig 2
    intc_1 // 0
    dig 2
    extract3
    dig 2
    ==
    b verify_string_startswith_ternary_merge@4


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_endswith[routing]() -> void:
verify_string_endswith:
    // tests/artifacts/PrimitiveOps/contract.py:341
    // @arc4.abimethod
    txna ApplicationArgs 1
    extract 2 0
    dup
    txna ApplicationArgs 2
    extract 2 0
    dup
    cover 2
    // tests/artifacts/PrimitiveOps/contract.py:343
    // result = a.endswith(b)
    len
    dup
    uncover 2
    len
    dup
    cover 2
    >
    bz verify_string_endswith_ternary_false@3
    intc_1 // 0

verify_string_endswith_ternary_merge@4:
    // tests/artifacts/PrimitiveOps/contract.py:341
    // @arc4.abimethod
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

verify_string_endswith_ternary_false@3:
    // tests/artifacts/PrimitiveOps/contract.py:343
    // result = a.endswith(b)
    dup
    dig 2
    dup
    cover 2
    -
    dig 5
    swap
    uncover 2
    extract3
    dig 3
    ==
    b verify_string_endswith_ternary_merge@4


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_join[routing]() -> void:
verify_string_join:
    // tests/artifacts/PrimitiveOps/contract.py:346
    // @arc4.abimethod
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:348
    // result = String(", ").join((a, b))
    swap
    pushbytes ", "
    concat
    swap
    concat
    // tests/artifacts/PrimitiveOps/contract.py:346
    // @arc4.abimethod
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_log[routing]() -> void:
verify_log:
    // tests/artifacts/PrimitiveOps/contract.py:351
    // @arc4.abimethod
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    txna ApplicationArgs 6
    txna ApplicationArgs 7
    txna ApplicationArgs 8
    txna ApplicationArgs 9
    txna ApplicationArgs 10
    txna ApplicationArgs 11
    extract 2 0
    txna ApplicationArgs 12
    extract 2 0
    txna ApplicationArgs 13
    extract 2 0
    txna ApplicationArgs 14
    // tests/artifacts/PrimitiveOps/contract.py:373
    // log(a, b, c, d_biguint, e, f, g, h, i, j, arc4_k, arc4_m, arc4_n, o, sep="-")
    uncover 13
    bytec_2 // "-"
    concat
    uncover 13
    itob
    concat
    bytec_2 // "-"
    concat
    uncover 12
    concat
    bytec_2 // "-"
    concat
    uncover 11
    concat
    bytec_2 // "-"
    concat
    uncover 10
    concat
    bytec_2 // "-"
    concat
    uncover 9
    concat
    bytec_2 // "-"
    concat
    uncover 8
    concat
    bytec_2 // "-"
    concat
    uncover 7
    concat
    bytec_2 // "-"
    concat
    uncover 6
    concat
    bytec_2 // "-"
    concat
    uncover 5
    concat
    bytec_2 // "-"
    concat
    uncover 4
    concat
    bytec_2 // "-"
    concat
    uncover 3
    concat
    bytec_2 // "-"
    concat
    uncover 2
    concat
    bytec_2 // "-"
    concat
    swap
    concat
    log
    // tests/artifacts/PrimitiveOps/contract.py:351
    // @arc4.abimethod
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"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","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the PrimitiveOpsContract contract + */ +export type PrimitiveOpsContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_uint64_init(byte[])uint64': { + rawValue: Uint8Array + } + 'verify_uint64_add(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_sub(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_mul(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_div(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_mod(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_and(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_or(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_xor(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_not(uint64)uint64': { + a: bigint | number + } + 'verify_uint64_lshift(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_rshift(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_pow(uint64,uint64)uint64': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_eq(uint64,uint64)bool': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_ne(uint64,uint64)bool': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_lt(uint64,uint64)bool': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_le(uint64,uint64)bool': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_gt(uint64,uint64)bool': { + a: bigint | number + b: bigint | number + } + 'verify_uint64_ge(uint64,uint64)bool': { + a: bigint | number + b: bigint | number + } + 'verify_bytes_init(uint64)byte[]': { + rawValue: bigint | number + } + 'verify_bytes_add(byte[],byte[],uint64,uint64)byte[]': { + a: Uint8Array + b: Uint8Array + padASize: bigint | number + padBSize: bigint | number + } + 'verify_bytes_eq(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_bytes_ne(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_bytes_and(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_bytes_or(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_bytes_xor(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_bytes_not(byte[],uint64)byte[]': { + a: Uint8Array + padSize: bigint | number + } + 'verify_biguint_add(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_add_uint64(byte[],uint64)byte[]': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_sub(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_sub_uint64(byte[],uint64)byte[]': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_mul(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_mul_uint64(byte[],uint64)byte[]': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_div(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_div_uint64(byte[],uint64)byte[]': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_mod(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_mod_uint64(byte[],uint64)byte[]': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_and(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_and_uint64(byte[],uint64)byte[]': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_or(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_or_uint64(byte[],uint64)byte[]': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_xor(byte[],byte[])byte[]': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_xor_uint64(byte[],uint64)byte[]': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_eq(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_eq_uint64(byte[],uint64)bool': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_ne(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_ne_uint64(byte[],uint64)bool': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_lt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_lt_uint64(byte[],uint64)bool': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_le(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_le_uint64(byte[],uint64)bool': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_gt(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_gt_uint64(byte[],uint64)bool': { + a: Uint8Array + b: bigint | number + } + 'verify_biguint_ge(byte[],byte[])bool': { + a: Uint8Array + b: Uint8Array + } + 'verify_biguint_ge_uint64(byte[],uint64)bool': { + a: Uint8Array + b: bigint | number + } + 'verify_string_init(string)string': { + a: string + } + 'verify_string_startswith(string,string)bool': { + a: string + b: string + } + 'verify_string_endswith(string,string)bool': { + a: string + b: string + } + 'verify_string_join(string,string)string': { + a: string + b: string + } + 'verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void': { + a: string + b: bigint | number + c: Uint8Array + d: Uint8Array + e: boolean + f: string + g: bigint | number + h: bigint | number + i: number + j: number + k: Uint8Array + m: Uint8Array + n: Uint8Array + o: Uint8Array + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_uint64_init(byte[])uint64': [rawValue: Uint8Array] + 'verify_uint64_add(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_sub(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_mul(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_div(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_mod(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_and(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_or(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_xor(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_not(uint64)uint64': [a: bigint | number] + 'verify_uint64_lshift(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_rshift(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_pow(uint64,uint64)uint64': [a: bigint | number, b: bigint | number] + 'verify_uint64_eq(uint64,uint64)bool': [a: bigint | number, b: bigint | number] + 'verify_uint64_ne(uint64,uint64)bool': [a: bigint | number, b: bigint | number] + 'verify_uint64_lt(uint64,uint64)bool': [a: bigint | number, b: bigint | number] + 'verify_uint64_le(uint64,uint64)bool': [a: bigint | number, b: bigint | number] + 'verify_uint64_gt(uint64,uint64)bool': [a: bigint | number, b: bigint | number] + 'verify_uint64_ge(uint64,uint64)bool': [a: bigint | number, b: bigint | number] + 'verify_bytes_init(uint64)byte[]': [rawValue: bigint | number] + 'verify_bytes_add(byte[],byte[],uint64,uint64)byte[]': [a: Uint8Array, b: Uint8Array, padASize: bigint | number, padBSize: bigint | number] + 'verify_bytes_eq(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_bytes_ne(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_bytes_and(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_bytes_or(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_bytes_xor(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_bytes_not(byte[],uint64)byte[]': [a: Uint8Array, padSize: bigint | number] + 'verify_biguint_add(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_add_uint64(byte[],uint64)byte[]': [a: Uint8Array, b: bigint | number] + 'verify_biguint_sub(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_sub_uint64(byte[],uint64)byte[]': [a: Uint8Array, b: bigint | number] + 'verify_biguint_mul(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_mul_uint64(byte[],uint64)byte[]': [a: Uint8Array, b: bigint | number] + 'verify_biguint_div(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_div_uint64(byte[],uint64)byte[]': [a: Uint8Array, b: bigint | number] + 'verify_biguint_mod(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_mod_uint64(byte[],uint64)byte[]': [a: Uint8Array, b: bigint | number] + 'verify_biguint_and(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_and_uint64(byte[],uint64)byte[]': [a: Uint8Array, b: bigint | number] + 'verify_biguint_or(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_or_uint64(byte[],uint64)byte[]': [a: Uint8Array, b: bigint | number] + 'verify_biguint_xor(byte[],byte[])byte[]': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_xor_uint64(byte[],uint64)byte[]': [a: Uint8Array, b: bigint | number] + 'verify_biguint_eq(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_eq_uint64(byte[],uint64)bool': [a: Uint8Array, b: bigint | number] + 'verify_biguint_ne(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_ne_uint64(byte[],uint64)bool': [a: Uint8Array, b: bigint | number] + 'verify_biguint_lt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_lt_uint64(byte[],uint64)bool': [a: Uint8Array, b: bigint | number] + 'verify_biguint_le(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_le_uint64(byte[],uint64)bool': [a: Uint8Array, b: bigint | number] + 'verify_biguint_gt(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_gt_uint64(byte[],uint64)bool': [a: Uint8Array, b: bigint | number] + 'verify_biguint_ge(byte[],byte[])bool': [a: Uint8Array, b: Uint8Array] + 'verify_biguint_ge_uint64(byte[],uint64)bool': [a: Uint8Array, b: bigint | number] + 'verify_string_init(string)string': [a: string] + 'verify_string_startswith(string,string)bool': [a: string, b: string] + 'verify_string_endswith(string,string)bool': [a: string, b: string] + 'verify_string_join(string,string)string': [a: string, b: string] + 'verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void': [a: string, b: bigint | number, c: Uint8Array, d: Uint8Array, e: boolean, f: string, g: bigint | number, h: bigint | number, i: number, j: number, k: Uint8Array, m: Uint8Array, n: Uint8Array, o: Uint8Array] + } +} + +/** + * The return type for each method + */ +export type PrimitiveOpsContractReturns = { + 'verify_uint64_init(byte[])uint64': bigint + 'verify_uint64_add(uint64,uint64)uint64': bigint + 'verify_uint64_sub(uint64,uint64)uint64': bigint + 'verify_uint64_mul(uint64,uint64)uint64': bigint + 'verify_uint64_div(uint64,uint64)uint64': bigint + 'verify_uint64_mod(uint64,uint64)uint64': bigint + 'verify_uint64_and(uint64,uint64)uint64': bigint + 'verify_uint64_or(uint64,uint64)uint64': bigint + 'verify_uint64_xor(uint64,uint64)uint64': bigint + 'verify_uint64_not(uint64)uint64': bigint + 'verify_uint64_lshift(uint64,uint64)uint64': bigint + 'verify_uint64_rshift(uint64,uint64)uint64': bigint + 'verify_uint64_pow(uint64,uint64)uint64': bigint + 'verify_uint64_eq(uint64,uint64)bool': boolean + 'verify_uint64_ne(uint64,uint64)bool': boolean + 'verify_uint64_lt(uint64,uint64)bool': boolean + 'verify_uint64_le(uint64,uint64)bool': boolean + 'verify_uint64_gt(uint64,uint64)bool': boolean + 'verify_uint64_ge(uint64,uint64)bool': boolean + 'verify_bytes_init(uint64)byte[]': Uint8Array + 'verify_bytes_add(byte[],byte[],uint64,uint64)byte[]': Uint8Array + 'verify_bytes_eq(byte[],byte[])bool': boolean + 'verify_bytes_ne(byte[],byte[])bool': boolean + 'verify_bytes_and(byte[],byte[])byte[]': Uint8Array + 'verify_bytes_or(byte[],byte[])byte[]': Uint8Array + 'verify_bytes_xor(byte[],byte[])byte[]': Uint8Array + 'verify_bytes_not(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_add(byte[],byte[])byte[]': Uint8Array + 'verify_biguint_add_uint64(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_sub(byte[],byte[])byte[]': Uint8Array + 'verify_biguint_sub_uint64(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_mul(byte[],byte[])byte[]': Uint8Array + 'verify_biguint_mul_uint64(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_div(byte[],byte[])byte[]': Uint8Array + 'verify_biguint_div_uint64(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_mod(byte[],byte[])byte[]': Uint8Array + 'verify_biguint_mod_uint64(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_and(byte[],byte[])byte[]': Uint8Array + 'verify_biguint_and_uint64(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_or(byte[],byte[])byte[]': Uint8Array + 'verify_biguint_or_uint64(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_xor(byte[],byte[])byte[]': Uint8Array + 'verify_biguint_xor_uint64(byte[],uint64)byte[]': Uint8Array + 'verify_biguint_eq(byte[],byte[])bool': boolean + 'verify_biguint_eq_uint64(byte[],uint64)bool': boolean + 'verify_biguint_ne(byte[],byte[])bool': boolean + 'verify_biguint_ne_uint64(byte[],uint64)bool': boolean + 'verify_biguint_lt(byte[],byte[])bool': boolean + 'verify_biguint_lt_uint64(byte[],uint64)bool': boolean + 'verify_biguint_le(byte[],byte[])bool': boolean + 'verify_biguint_le_uint64(byte[],uint64)bool': boolean + 'verify_biguint_gt(byte[],byte[])bool': boolean + 'verify_biguint_gt_uint64(byte[],uint64)bool': boolean + 'verify_biguint_ge(byte[],byte[])bool': boolean + 'verify_biguint_ge_uint64(byte[],uint64)bool': boolean + 'verify_string_init(string)string': string + 'verify_string_startswith(string,string)bool': boolean + 'verify_string_endswith(string,string)bool': boolean + 'verify_string_join(string,string)string': string + 'verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void': void +} + +/** + * Defines the types of available calls and state of the PrimitiveOpsContract smart contract. + */ +export type PrimitiveOpsContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_uint64_init(byte[])uint64' | 'verify_uint64_init', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_init(byte[])uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_init(byte[])uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_init(byte[])uint64'] + }> + & Record<'verify_uint64_add(uint64,uint64)uint64' | 'verify_uint64_add', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_add(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_add(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_add(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_sub(uint64,uint64)uint64' | 'verify_uint64_sub', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_sub(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_sub(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_sub(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_mul(uint64,uint64)uint64' | 'verify_uint64_mul', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_mul(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_mul(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_mul(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_div(uint64,uint64)uint64' | 'verify_uint64_div', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_div(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_div(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_div(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_mod(uint64,uint64)uint64' | 'verify_uint64_mod', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_mod(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_mod(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_mod(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_and(uint64,uint64)uint64' | 'verify_uint64_and', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_and(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_and(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_and(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_or(uint64,uint64)uint64' | 'verify_uint64_or', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_or(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_or(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_or(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_xor(uint64,uint64)uint64' | 'verify_uint64_xor', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_xor(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_xor(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_xor(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_not(uint64)uint64' | 'verify_uint64_not', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_not(uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_not(uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_not(uint64)uint64'] + }> + & Record<'verify_uint64_lshift(uint64,uint64)uint64' | 'verify_uint64_lshift', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_lshift(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_lshift(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_lshift(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_rshift(uint64,uint64)uint64' | 'verify_uint64_rshift', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_rshift(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_rshift(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_rshift(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_pow(uint64,uint64)uint64' | 'verify_uint64_pow', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_pow(uint64,uint64)uint64'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_pow(uint64,uint64)uint64'] + returns: PrimitiveOpsContractReturns['verify_uint64_pow(uint64,uint64)uint64'] + }> + & Record<'verify_uint64_eq(uint64,uint64)bool' | 'verify_uint64_eq', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_eq(uint64,uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_eq(uint64,uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_uint64_eq(uint64,uint64)bool'] + }> + & Record<'verify_uint64_ne(uint64,uint64)bool' | 'verify_uint64_ne', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_ne(uint64,uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_ne(uint64,uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_uint64_ne(uint64,uint64)bool'] + }> + & Record<'verify_uint64_lt(uint64,uint64)bool' | 'verify_uint64_lt', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_lt(uint64,uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_lt(uint64,uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_uint64_lt(uint64,uint64)bool'] + }> + & Record<'verify_uint64_le(uint64,uint64)bool' | 'verify_uint64_le', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_le(uint64,uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_le(uint64,uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_uint64_le(uint64,uint64)bool'] + }> + & Record<'verify_uint64_gt(uint64,uint64)bool' | 'verify_uint64_gt', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_gt(uint64,uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_gt(uint64,uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_uint64_gt(uint64,uint64)bool'] + }> + & Record<'verify_uint64_ge(uint64,uint64)bool' | 'verify_uint64_ge', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_uint64_ge(uint64,uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_uint64_ge(uint64,uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_uint64_ge(uint64,uint64)bool'] + }> + & Record<'verify_bytes_init(uint64)byte[]' | 'verify_bytes_init', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_bytes_init(uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_bytes_init(uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_bytes_init(uint64)byte[]'] + }> + & Record<'verify_bytes_add(byte[],byte[],uint64,uint64)byte[]' | 'verify_bytes_add', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_bytes_add(byte[],byte[],uint64,uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_bytes_add(byte[],byte[],uint64,uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_bytes_add(byte[],byte[],uint64,uint64)byte[]'] + }> + & Record<'verify_bytes_eq(byte[],byte[])bool' | 'verify_bytes_eq', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_bytes_eq(byte[],byte[])bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_bytes_eq(byte[],byte[])bool'] + returns: PrimitiveOpsContractReturns['verify_bytes_eq(byte[],byte[])bool'] + }> + & Record<'verify_bytes_ne(byte[],byte[])bool' | 'verify_bytes_ne', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_bytes_ne(byte[],byte[])bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_bytes_ne(byte[],byte[])bool'] + returns: PrimitiveOpsContractReturns['verify_bytes_ne(byte[],byte[])bool'] + }> + & Record<'verify_bytes_and(byte[],byte[])byte[]' | 'verify_bytes_and', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_bytes_and(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_bytes_and(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_bytes_and(byte[],byte[])byte[]'] + }> + & Record<'verify_bytes_or(byte[],byte[])byte[]' | 'verify_bytes_or', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_bytes_or(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_bytes_or(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_bytes_or(byte[],byte[])byte[]'] + }> + & Record<'verify_bytes_xor(byte[],byte[])byte[]' | 'verify_bytes_xor', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_bytes_xor(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_bytes_xor(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_bytes_xor(byte[],byte[])byte[]'] + }> + & Record<'verify_bytes_not(byte[],uint64)byte[]' | 'verify_bytes_not', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_bytes_not(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_bytes_not(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_bytes_not(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_add(byte[],byte[])byte[]' | 'verify_biguint_add', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_add(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_add(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_add(byte[],byte[])byte[]'] + }> + & Record<'verify_biguint_add_uint64(byte[],uint64)byte[]' | 'verify_biguint_add_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_add_uint64(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_add_uint64(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_add_uint64(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_sub(byte[],byte[])byte[]' | 'verify_biguint_sub', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_sub(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_sub(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_sub(byte[],byte[])byte[]'] + }> + & Record<'verify_biguint_sub_uint64(byte[],uint64)byte[]' | 'verify_biguint_sub_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_sub_uint64(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_sub_uint64(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_sub_uint64(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_mul(byte[],byte[])byte[]' | 'verify_biguint_mul', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_mul(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_mul(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_mul(byte[],byte[])byte[]'] + }> + & Record<'verify_biguint_mul_uint64(byte[],uint64)byte[]' | 'verify_biguint_mul_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_mul_uint64(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_mul_uint64(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_mul_uint64(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_div(byte[],byte[])byte[]' | 'verify_biguint_div', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_div(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_div(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_div(byte[],byte[])byte[]'] + }> + & Record<'verify_biguint_div_uint64(byte[],uint64)byte[]' | 'verify_biguint_div_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_div_uint64(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_div_uint64(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_div_uint64(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_mod(byte[],byte[])byte[]' | 'verify_biguint_mod', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_mod(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_mod(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_mod(byte[],byte[])byte[]'] + }> + & Record<'verify_biguint_mod_uint64(byte[],uint64)byte[]' | 'verify_biguint_mod_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_mod_uint64(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_mod_uint64(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_mod_uint64(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_and(byte[],byte[])byte[]' | 'verify_biguint_and', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_and(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_and(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_and(byte[],byte[])byte[]'] + }> + & Record<'verify_biguint_and_uint64(byte[],uint64)byte[]' | 'verify_biguint_and_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_and_uint64(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_and_uint64(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_and_uint64(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_or(byte[],byte[])byte[]' | 'verify_biguint_or', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_or(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_or(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_or(byte[],byte[])byte[]'] + }> + & Record<'verify_biguint_or_uint64(byte[],uint64)byte[]' | 'verify_biguint_or_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_or_uint64(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_or_uint64(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_or_uint64(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_xor(byte[],byte[])byte[]' | 'verify_biguint_xor', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_xor(byte[],byte[])byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_xor(byte[],byte[])byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_xor(byte[],byte[])byte[]'] + }> + & Record<'verify_biguint_xor_uint64(byte[],uint64)byte[]' | 'verify_biguint_xor_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_xor_uint64(byte[],uint64)byte[]'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_xor_uint64(byte[],uint64)byte[]'] + returns: PrimitiveOpsContractReturns['verify_biguint_xor_uint64(byte[],uint64)byte[]'] + }> + & Record<'verify_biguint_eq(byte[],byte[])bool' | 'verify_biguint_eq', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_eq(byte[],byte[])bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_eq(byte[],byte[])bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_eq(byte[],byte[])bool'] + }> + & Record<'verify_biguint_eq_uint64(byte[],uint64)bool' | 'verify_biguint_eq_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_eq_uint64(byte[],uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_eq_uint64(byte[],uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_eq_uint64(byte[],uint64)bool'] + }> + & Record<'verify_biguint_ne(byte[],byte[])bool' | 'verify_biguint_ne', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_ne(byte[],byte[])bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_ne(byte[],byte[])bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_ne(byte[],byte[])bool'] + }> + & Record<'verify_biguint_ne_uint64(byte[],uint64)bool' | 'verify_biguint_ne_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_ne_uint64(byte[],uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_ne_uint64(byte[],uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_ne_uint64(byte[],uint64)bool'] + }> + & Record<'verify_biguint_lt(byte[],byte[])bool' | 'verify_biguint_lt', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_lt(byte[],byte[])bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_lt(byte[],byte[])bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_lt(byte[],byte[])bool'] + }> + & Record<'verify_biguint_lt_uint64(byte[],uint64)bool' | 'verify_biguint_lt_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_lt_uint64(byte[],uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_lt_uint64(byte[],uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_lt_uint64(byte[],uint64)bool'] + }> + & Record<'verify_biguint_le(byte[],byte[])bool' | 'verify_biguint_le', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_le(byte[],byte[])bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_le(byte[],byte[])bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_le(byte[],byte[])bool'] + }> + & Record<'verify_biguint_le_uint64(byte[],uint64)bool' | 'verify_biguint_le_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_le_uint64(byte[],uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_le_uint64(byte[],uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_le_uint64(byte[],uint64)bool'] + }> + & Record<'verify_biguint_gt(byte[],byte[])bool' | 'verify_biguint_gt', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_gt(byte[],byte[])bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_gt(byte[],byte[])bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_gt(byte[],byte[])bool'] + }> + & Record<'verify_biguint_gt_uint64(byte[],uint64)bool' | 'verify_biguint_gt_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_gt_uint64(byte[],uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_gt_uint64(byte[],uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_gt_uint64(byte[],uint64)bool'] + }> + & Record<'verify_biguint_ge(byte[],byte[])bool' | 'verify_biguint_ge', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_ge(byte[],byte[])bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_ge(byte[],byte[])bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_ge(byte[],byte[])bool'] + }> + & Record<'verify_biguint_ge_uint64(byte[],uint64)bool' | 'verify_biguint_ge_uint64', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_biguint_ge_uint64(byte[],uint64)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_biguint_ge_uint64(byte[],uint64)bool'] + returns: PrimitiveOpsContractReturns['verify_biguint_ge_uint64(byte[],uint64)bool'] + }> + & Record<'verify_string_init(string)string' | 'verify_string_init', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_string_init(string)string'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_string_init(string)string'] + returns: PrimitiveOpsContractReturns['verify_string_init(string)string'] + }> + & Record<'verify_string_startswith(string,string)bool' | 'verify_string_startswith', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_string_startswith(string,string)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_string_startswith(string,string)bool'] + returns: PrimitiveOpsContractReturns['verify_string_startswith(string,string)bool'] + }> + & Record<'verify_string_endswith(string,string)bool' | 'verify_string_endswith', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_string_endswith(string,string)bool'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_string_endswith(string,string)bool'] + returns: PrimitiveOpsContractReturns['verify_string_endswith(string,string)bool'] + }> + & Record<'verify_string_join(string,string)string' | 'verify_string_join', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_string_join(string,string)string'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_string_join(string,string)string'] + returns: PrimitiveOpsContractReturns['verify_string_join(string,string)string'] + }> + & Record<'verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void' | 'verify_log', { + argsObj: PrimitiveOpsContractArgs['obj']['verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void'] + argsTuple: PrimitiveOpsContractArgs['tuple']['verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void'] + returns: PrimitiveOpsContractReturns['verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type PrimitiveOpsContractSignatures = keyof PrimitiveOpsContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type PrimitiveOpsContractNonVoidMethodSignatures = keyof PrimitiveOpsContractTypes['methods'] extends infer T ? T extends keyof PrimitiveOpsContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the PrimitiveOpsContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = PrimitiveOpsContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the PrimitiveOpsContract smart contract to the method's return type + */ +export type MethodReturn = PrimitiveOpsContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type PrimitiveOpsContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type PrimitiveOpsContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: PrimitiveOpsContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the PrimitiveOpsContract smart contract + */ +export abstract class PrimitiveOpsContractParamsFactory { + /** + * Constructs a no op call for the verify_uint64_init(byte[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Init(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_init(byte[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.rawValue], + } + } + /** + * Constructs a no op call for the verify_uint64_add(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Add(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_add(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_sub(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Sub(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_sub(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_mul(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Mul(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_mul(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_div(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Div(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_div(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_mod(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Mod(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_mod(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_and(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64And(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_and(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_or(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Or(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_or(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_xor(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Xor(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_xor(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_not(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Not(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_not(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_uint64_lshift(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Lshift(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_lshift(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_rshift(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Rshift(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_rshift(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_pow(uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Pow(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_pow(uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_eq(uint64,uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Eq(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_eq(uint64,uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_ne(uint64,uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Ne(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_ne(uint64,uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_lt(uint64,uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Lt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_lt(uint64,uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_le(uint64,uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Le(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_le(uint64,uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_gt(uint64,uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Gt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_gt(uint64,uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_uint64_ge(uint64,uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyUint64Ge(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_uint64_ge(uint64,uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_bytes_init(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_init(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.rawValue], + } + } + /** + * Constructs a no op call for the verify_bytes_add(byte[],byte[],uint64,uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesAdd(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_add(byte[],byte[],uint64,uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.padASize, params.args.padBSize], + } + } + /** + * Constructs a no op call for the verify_bytes_eq(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesEq(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_eq(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_bytes_ne(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesNe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_ne(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_bytes_and(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesAnd(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_and(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_bytes_or(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesOr(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_or(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_bytes_xor(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesXor(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_xor(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_bytes_not(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBytesNot(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_bytes_not(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.padSize], + } + } + /** + * Constructs a no op call for the verify_biguint_add(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintAdd(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_add(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_add_uint64(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintAddUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_add_uint64(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_sub(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintSub(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_sub(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_sub_uint64(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintSubUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_sub_uint64(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_mul(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintMul(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_mul(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_mul_uint64(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintMulUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_mul_uint64(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_div(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintDiv(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_div(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_div_uint64(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintDivUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_div_uint64(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_mod(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintMod(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_mod(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_mod_uint64(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintModUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_mod_uint64(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_and(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintAnd(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_and(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_and_uint64(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintAndUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_and_uint64(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_or(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintOr(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_or(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_or_uint64(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintOrUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_or_uint64(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_xor(byte[],byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintXor(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_xor(byte[],byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_xor_uint64(byte[],uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintXorUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_xor_uint64(byte[],uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_eq(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintEq(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_eq(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_eq_uint64(byte[],uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintEqUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_eq_uint64(byte[],uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_ne(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintNe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_ne(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_ne_uint64(byte[],uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintNeUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_ne_uint64(byte[],uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_lt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintLt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_lt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_lt_uint64(byte[],uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintLtUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_lt_uint64(byte[],uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_le(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintLe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_le(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_le_uint64(byte[],uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintLeUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_le_uint64(byte[],uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_gt(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintGt(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_gt(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_gt_uint64(byte[],uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintGtUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_gt_uint64(byte[],uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_ge(byte[],byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintGe(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_ge(byte[],byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_biguint_ge_uint64(byte[],uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyBiguintGeUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_biguint_ge_uint64(byte[],uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_string_init(string)string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringInit(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_init(string)string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_string_startswith(string,string)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringStartswith(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_startswith(string,string)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_string_endswith(string,string)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringEndswith(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_endswith(string,string)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_string_join(string,string)string ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyStringJoin(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_string_join(string,string)string' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyLog(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c, params.args.d, params.args.e, params.args.f, params.args.g, params.args.h, params.args.i, params.args.j, params.args.k, params.args.m, params.args.n, params.args.o], + } + } +} + +/** + * A factory to create and deploy one or more instance of the PrimitiveOpsContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class PrimitiveOpsContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `PrimitiveOpsContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new PrimitiveOpsContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new PrimitiveOpsContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the PrimitiveOpsContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: PrimitiveOpsContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new PrimitiveOpsContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the PrimitiveOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the PrimitiveOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the PrimitiveOpsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new PrimitiveOpsContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the PrimitiveOpsContract smart contract + */ +export class PrimitiveOpsContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `PrimitiveOpsContractClient` + * + * @param appClient An `AppClient` instance which has been created with the PrimitiveOpsContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `PrimitiveOpsContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `PrimitiveOpsContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new PrimitiveOpsContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `PrimitiveOpsContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new PrimitiveOpsContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the PrimitiveOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_init(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Init: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Init(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_add(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Add: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Add(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_sub(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Sub: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Sub(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_mul(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Mul: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Mul(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_div(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Div: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Div(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_mod(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Mod: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Mod(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_and(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64And: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64And(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_or(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Or: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Or(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_xor(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Xor: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Xor(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_not(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Not: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Not(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_lshift(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Lshift: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Lshift(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_rshift(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Rshift: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Rshift(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_pow(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Pow: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Pow(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_eq(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Eq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Eq(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_ne(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Ne: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Ne(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_lt(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Lt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Lt(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_le(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Le: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Le(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_gt(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Gt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Gt(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_ge(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyUint64Ge: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyUint64Ge(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_init(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBytesInit(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_add(byte[],byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesAdd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBytesAdd(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBytesEq(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBytesNe(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_and(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesAnd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBytesAnd(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_or(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesOr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBytesOr(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_xor(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesXor: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBytesXor(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_not(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBytesNot: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBytesNot(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_add(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintAdd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintAdd(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_add_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintAddUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintAddUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_sub(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintSub: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintSub(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_sub_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintSubUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintSubUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mul(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintMul: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintMul(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mul_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintMulUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintMulUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_div(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintDiv: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintDiv(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_div_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintDivUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintDivUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mod(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintMod: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintMod(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mod_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintModUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintModUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_and(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintAnd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintAnd(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_and_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintAndUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintAndUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_or(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintOr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintOr(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_or_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintOrUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintOrUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_xor(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintXor: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintXor(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_xor_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintXorUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintXorUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintEq(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_eq_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintEqUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintEqUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintNe(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ne_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintNeUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintNeUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintLt(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_lt_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintLtUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintLtUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintLe(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_le_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintLeUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintLeUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintGt(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_gt_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintGtUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintGtUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintGe(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ge_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyBiguintGeUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyBiguintGeUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_init(string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyStringInit(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_startswith(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringStartswith: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyStringStartswith(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_endswith(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringEndswith: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyStringEndswith(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_join(string,string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyStringJoin: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyStringJoin(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(PrimitiveOpsContractParamsFactory.verifyLog(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the PrimitiveOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_init(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Init: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Init(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_add(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Add: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Add(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_sub(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Sub: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Sub(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_mul(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Mul: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Mul(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_div(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Div: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Div(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_mod(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Mod: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Mod(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_and(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64And: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64And(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_or(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Or: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Or(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_xor(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Xor: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Xor(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_not(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Not: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Not(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_lshift(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Lshift: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Lshift(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_rshift(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Rshift: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Rshift(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_pow(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Pow: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Pow(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_eq(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Eq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Eq(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_ne(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Ne: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Ne(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_lt(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Lt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Lt(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_le(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Le: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Le(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_gt(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Gt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Gt(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_ge(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyUint64Ge: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyUint64Ge(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_init(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBytesInit(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_add(byte[],byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesAdd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBytesAdd(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBytesEq(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBytesNe(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_and(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesAnd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBytesAnd(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_or(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesOr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBytesOr(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_xor(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesXor: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBytesXor(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_not(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBytesNot: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBytesNot(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_add(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintAdd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintAdd(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_add_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintAddUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintAddUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_sub(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintSub: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintSub(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_sub_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintSubUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintSubUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mul(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintMul: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintMul(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mul_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintMulUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintMulUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_div(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintDiv: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintDiv(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_div_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintDivUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintDivUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mod(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintMod: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintMod(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mod_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintModUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintModUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_and(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintAnd: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintAnd(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_and_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintAndUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintAndUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_or(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintOr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintOr(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_or_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintOrUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintOrUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_xor(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintXor: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintXor(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_xor_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintXorUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintXorUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintEq: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintEq(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_eq_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintEqUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintEqUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintNe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintNe(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ne_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintNeUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintNeUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintLt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintLt(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_lt_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintLtUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintLtUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintLe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintLe(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_le_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintLeUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintLeUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintGt: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintGt(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_gt_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintGtUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintGtUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintGe: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintGe(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ge_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyBiguintGeUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyBiguintGeUint64(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_init(string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringInit: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyStringInit(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_startswith(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringStartswith: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyStringStartswith(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_endswith(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringEndswith: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyStringEndswith(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_join(string,string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyStringJoin: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyStringJoin(params)) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyLog: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(PrimitiveOpsContractParamsFactory.verifyLog(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the PrimitiveOpsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_init(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Init: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Init(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_init(byte[])uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_add(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Add: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Add(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_add(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_sub(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Sub: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Sub(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_sub(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_mul(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Mul: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Mul(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_mul(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_div(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Div: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Div(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_div(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_mod(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Mod: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Mod(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_mod(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_and(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64And: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64And(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_and(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_or(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Or: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Or(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_or(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_xor(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Xor: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Xor(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_xor(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_not(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Not: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Not(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_not(uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_lshift(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Lshift: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Lshift(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_lshift(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_rshift(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Rshift: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Rshift(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_rshift(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_pow(uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Pow: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Pow(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_pow(uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_eq(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Eq: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Eq(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_eq(uint64,uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_ne(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Ne: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Ne(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_ne(uint64,uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_lt(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Lt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Lt(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_lt(uint64,uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_le(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Le: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Le(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_le(uint64,uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_gt(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Gt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Gt(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_gt(uint64,uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_uint64_ge(uint64,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyUint64Ge: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyUint64Ge(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_uint64_ge(uint64,uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_init(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBytesInit(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_bytes_init(uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_add(byte[],byte[],uint64,uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesAdd: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBytesAdd(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_bytes_add(byte[],byte[],uint64,uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesEq: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBytesEq(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_bytes_eq(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesNe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBytesNe(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_bytes_ne(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_and(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesAnd: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBytesAnd(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_bytes_and(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_or(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesOr: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBytesOr(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_bytes_or(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_xor(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesXor: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBytesXor(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_bytes_xor(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_bytes_not(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBytesNot: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBytesNot(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_bytes_not(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_add(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintAdd: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintAdd(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_add(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_add_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintAddUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintAddUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_add_uint64(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_sub(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintSub: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintSub(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_sub(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_sub_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintSubUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintSubUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_sub_uint64(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mul(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintMul: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintMul(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_mul(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mul_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintMulUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintMulUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_mul_uint64(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_div(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintDiv: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintDiv(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_div(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_div_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintDivUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintDivUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_div_uint64(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mod(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintMod: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintMod(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_mod(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_mod_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintModUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintModUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_mod_uint64(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_and(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintAnd: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintAnd(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_and(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_and_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintAndUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintAndUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_and_uint64(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_or(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintOr: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintOr(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_or(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_or_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintOrUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintOrUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_or_uint64(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_xor(byte[],byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintXor: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintXor(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_xor(byte[],byte[])byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_xor_uint64(byte[],uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintXorUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintXorUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_xor_uint64(byte[],uint64)byte[]'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_eq(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintEq: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintEq(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_eq(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_eq_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintEqUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintEqUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_eq_uint64(byte[],uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ne(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintNe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintNe(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_ne(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ne_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintNeUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintNeUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_ne_uint64(byte[],uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_lt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintLt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintLt(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_lt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_lt_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintLtUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintLtUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_lt_uint64(byte[],uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_le(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintLe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintLe(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_le(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_le_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintLeUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintLeUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_le_uint64(byte[],uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_gt(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintGt: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintGt(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_gt(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_gt_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintGtUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintGtUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_gt_uint64(byte[],uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ge(byte[],byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintGe: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintGe(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_ge(byte[],byte[])bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_biguint_ge_uint64(byte[],uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyBiguintGeUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyBiguintGeUint64(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_biguint_ge_uint64(byte[],uint64)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_init(string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringInit: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyStringInit(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_string_init(string)string'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_startswith(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringStartswith: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyStringStartswith(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_string_startswith(string,string)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_endswith(string,string)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringEndswith: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyStringEndswith(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_string_endswith(string,string)bool'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_string_join(string,string)string` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyStringJoin: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyStringJoin(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_string_join(string,string)string'])} + }, + + /** + * Makes a call to the PrimitiveOpsContract smart contract using the `verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyLog: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(PrimitiveOpsContractParamsFactory.verifyLog(params)) + return {...result, return: result.return as unknown as (undefined | PrimitiveOpsContractReturns['verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new PrimitiveOpsContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current PrimitiveOpsContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): PrimitiveOpsContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_uint64_init(byte[])uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Init(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Init(params))) + return this + }, + /** + * Add a verify_uint64_add(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Add(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Add(params))) + return this + }, + /** + * Add a verify_uint64_sub(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Sub(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Sub(params))) + return this + }, + /** + * Add a verify_uint64_mul(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Mul(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Mul(params))) + return this + }, + /** + * Add a verify_uint64_div(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Div(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Div(params))) + return this + }, + /** + * Add a verify_uint64_mod(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Mod(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Mod(params))) + return this + }, + /** + * Add a verify_uint64_and(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64And(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64And(params))) + return this + }, + /** + * Add a verify_uint64_or(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Or(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Or(params))) + return this + }, + /** + * Add a verify_uint64_xor(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Xor(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Xor(params))) + return this + }, + /** + * Add a verify_uint64_not(uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Not(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Not(params))) + return this + }, + /** + * Add a verify_uint64_lshift(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Lshift(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Lshift(params))) + return this + }, + /** + * Add a verify_uint64_rshift(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Rshift(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Rshift(params))) + return this + }, + /** + * Add a verify_uint64_pow(uint64,uint64)uint64 method call against the PrimitiveOpsContract contract + */ + verifyUint64Pow(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Pow(params))) + return this + }, + /** + * Add a verify_uint64_eq(uint64,uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyUint64Eq(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Eq(params))) + return this + }, + /** + * Add a verify_uint64_ne(uint64,uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyUint64Ne(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Ne(params))) + return this + }, + /** + * Add a verify_uint64_lt(uint64,uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyUint64Lt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Lt(params))) + return this + }, + /** + * Add a verify_uint64_le(uint64,uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyUint64Le(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Le(params))) + return this + }, + /** + * Add a verify_uint64_gt(uint64,uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyUint64Gt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Gt(params))) + return this + }, + /** + * Add a verify_uint64_ge(uint64,uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyUint64Ge(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyUint64Ge(params))) + return this + }, + /** + * Add a verify_bytes_init(uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBytesInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesInit(params))) + return this + }, + /** + * Add a verify_bytes_add(byte[],byte[],uint64,uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBytesAdd(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesAdd(params))) + return this + }, + /** + * Add a verify_bytes_eq(byte[],byte[])bool method call against the PrimitiveOpsContract contract + */ + verifyBytesEq(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesEq(params))) + return this + }, + /** + * Add a verify_bytes_ne(byte[],byte[])bool method call against the PrimitiveOpsContract contract + */ + verifyBytesNe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesNe(params))) + return this + }, + /** + * Add a verify_bytes_and(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBytesAnd(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesAnd(params))) + return this + }, + /** + * Add a verify_bytes_or(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBytesOr(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesOr(params))) + return this + }, + /** + * Add a verify_bytes_xor(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBytesXor(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesXor(params))) + return this + }, + /** + * Add a verify_bytes_not(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBytesNot(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBytesNot(params))) + return this + }, + /** + * Add a verify_biguint_add(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintAdd(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintAdd(params))) + return this + }, + /** + * Add a verify_biguint_add_uint64(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintAddUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintAddUint64(params))) + return this + }, + /** + * Add a verify_biguint_sub(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintSub(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintSub(params))) + return this + }, + /** + * Add a verify_biguint_sub_uint64(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintSubUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintSubUint64(params))) + return this + }, + /** + * Add a verify_biguint_mul(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintMul(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintMul(params))) + return this + }, + /** + * Add a verify_biguint_mul_uint64(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintMulUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintMulUint64(params))) + return this + }, + /** + * Add a verify_biguint_div(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintDiv(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintDiv(params))) + return this + }, + /** + * Add a verify_biguint_div_uint64(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintDivUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintDivUint64(params))) + return this + }, + /** + * Add a verify_biguint_mod(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintMod(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintMod(params))) + return this + }, + /** + * Add a verify_biguint_mod_uint64(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintModUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintModUint64(params))) + return this + }, + /** + * Add a verify_biguint_and(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintAnd(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintAnd(params))) + return this + }, + /** + * Add a verify_biguint_and_uint64(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintAndUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintAndUint64(params))) + return this + }, + /** + * Add a verify_biguint_or(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintOr(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintOr(params))) + return this + }, + /** + * Add a verify_biguint_or_uint64(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintOrUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintOrUint64(params))) + return this + }, + /** + * Add a verify_biguint_xor(byte[],byte[])byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintXor(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintXor(params))) + return this + }, + /** + * Add a verify_biguint_xor_uint64(byte[],uint64)byte[] method call against the PrimitiveOpsContract contract + */ + verifyBiguintXorUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintXorUint64(params))) + return this + }, + /** + * Add a verify_biguint_eq(byte[],byte[])bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintEq(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintEq(params))) + return this + }, + /** + * Add a verify_biguint_eq_uint64(byte[],uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintEqUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintEqUint64(params))) + return this + }, + /** + * Add a verify_biguint_ne(byte[],byte[])bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintNe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintNe(params))) + return this + }, + /** + * Add a verify_biguint_ne_uint64(byte[],uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintNeUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintNeUint64(params))) + return this + }, + /** + * Add a verify_biguint_lt(byte[],byte[])bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintLt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintLt(params))) + return this + }, + /** + * Add a verify_biguint_lt_uint64(byte[],uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintLtUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintLtUint64(params))) + return this + }, + /** + * Add a verify_biguint_le(byte[],byte[])bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintLe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintLe(params))) + return this + }, + /** + * Add a verify_biguint_le_uint64(byte[],uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintLeUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintLeUint64(params))) + return this + }, + /** + * Add a verify_biguint_gt(byte[],byte[])bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintGt(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintGt(params))) + return this + }, + /** + * Add a verify_biguint_gt_uint64(byte[],uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintGtUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintGtUint64(params))) + return this + }, + /** + * Add a verify_biguint_ge(byte[],byte[])bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintGe(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintGe(params))) + return this + }, + /** + * Add a verify_biguint_ge_uint64(byte[],uint64)bool method call against the PrimitiveOpsContract contract + */ + verifyBiguintGeUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyBiguintGeUint64(params))) + return this + }, + /** + * Add a verify_string_init(string)string method call against the PrimitiveOpsContract contract + */ + verifyStringInit(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringInit(params))) + return this + }, + /** + * Add a verify_string_startswith(string,string)bool method call against the PrimitiveOpsContract contract + */ + verifyStringStartswith(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringStartswith(params))) + return this + }, + /** + * Add a verify_string_endswith(string,string)bool method call against the PrimitiveOpsContract contract + */ + verifyStringEndswith(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringEndswith(params))) + return this + }, + /** + * Add a verify_string_join(string,string)string method call against the PrimitiveOpsContract contract + */ + verifyStringJoin(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyStringJoin(params))) + return this + }, + /** + * Add a verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void method call against the PrimitiveOpsContract contract + */ + verifyLog(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyLog(params))) + return this + }, + /** + * Add a clear state call to the PrimitiveOpsContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as PrimitiveOpsContractComposer + } +} +export type PrimitiveOpsContractComposer = { + /** + * Calls the verify_uint64_init(byte[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Init(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_init(byte[])uint64'] | undefined]> + + /** + * Calls the verify_uint64_add(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Add(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_add(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_sub(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Sub(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_sub(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_mul(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Mul(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_mul(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_div(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Div(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_div(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_mod(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Mod(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_mod(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_and(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64And(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_and(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_or(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Or(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_or(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_xor(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Xor(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_xor(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_not(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Not(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_not(uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_lshift(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Lshift(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_lshift(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_rshift(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Rshift(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_rshift(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_pow(uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Pow(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_pow(uint64,uint64)uint64'] | undefined]> + + /** + * Calls the verify_uint64_eq(uint64,uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Eq(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_eq(uint64,uint64)bool'] | undefined]> + + /** + * Calls the verify_uint64_ne(uint64,uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Ne(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_ne(uint64,uint64)bool'] | undefined]> + + /** + * Calls the verify_uint64_lt(uint64,uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Lt(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_lt(uint64,uint64)bool'] | undefined]> + + /** + * Calls the verify_uint64_le(uint64,uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Le(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_le(uint64,uint64)bool'] | undefined]> + + /** + * Calls the verify_uint64_gt(uint64,uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Gt(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_gt(uint64,uint64)bool'] | undefined]> + + /** + * Calls the verify_uint64_ge(uint64,uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyUint64Ge(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_uint64_ge(uint64,uint64)bool'] | undefined]> + + /** + * Calls the verify_bytes_init(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesInit(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_bytes_init(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_bytes_add(byte[],byte[],uint64,uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesAdd(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_bytes_add(byte[],byte[],uint64,uint64)byte[]'] | undefined]> + + /** + * Calls the verify_bytes_eq(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesEq(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_bytes_eq(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_bytes_ne(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesNe(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_bytes_ne(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_bytes_and(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesAnd(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_bytes_and(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_bytes_or(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesOr(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_bytes_or(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_bytes_xor(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesXor(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_bytes_xor(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_bytes_not(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBytesNot(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_bytes_not(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_add(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintAdd(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_add(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_biguint_add_uint64(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintAddUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_add_uint64(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_sub(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintSub(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_sub(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_biguint_sub_uint64(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintSubUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_sub_uint64(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_mul(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintMul(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_mul(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_biguint_mul_uint64(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintMulUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_mul_uint64(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_div(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintDiv(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_div(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_biguint_div_uint64(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintDivUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_div_uint64(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_mod(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintMod(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_mod(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_biguint_mod_uint64(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintModUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_mod_uint64(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_and(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintAnd(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_and(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_biguint_and_uint64(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintAndUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_and_uint64(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_or(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintOr(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_or(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_biguint_or_uint64(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintOrUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_or_uint64(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_xor(byte[],byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintXor(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_xor(byte[],byte[])byte[]'] | undefined]> + + /** + * Calls the verify_biguint_xor_uint64(byte[],uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintXorUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_xor_uint64(byte[],uint64)byte[]'] | undefined]> + + /** + * Calls the verify_biguint_eq(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintEq(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_eq(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguint_eq_uint64(byte[],uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintEqUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_eq_uint64(byte[],uint64)bool'] | undefined]> + + /** + * Calls the verify_biguint_ne(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintNe(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_ne(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguint_ne_uint64(byte[],uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintNeUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_ne_uint64(byte[],uint64)bool'] | undefined]> + + /** + * Calls the verify_biguint_lt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintLt(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_lt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguint_lt_uint64(byte[],uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintLtUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_lt_uint64(byte[],uint64)bool'] | undefined]> + + /** + * Calls the verify_biguint_le(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintLe(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_le(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguint_le_uint64(byte[],uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintLeUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_le_uint64(byte[],uint64)bool'] | undefined]> + + /** + * Calls the verify_biguint_gt(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintGt(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_gt(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguint_gt_uint64(byte[],uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintGtUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_gt_uint64(byte[],uint64)bool'] | undefined]> + + /** + * Calls the verify_biguint_ge(byte[],byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintGe(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_ge(byte[],byte[])bool'] | undefined]> + + /** + * Calls the verify_biguint_ge_uint64(byte[],uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyBiguintGeUint64(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_biguint_ge_uint64(byte[],uint64)bool'] | undefined]> + + /** + * Calls the verify_string_init(string)string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringInit(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_string_init(string)string'] | undefined]> + + /** + * Calls the verify_string_startswith(string,string)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringStartswith(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_string_startswith(string,string)bool'] | undefined]> + + /** + * Calls the verify_string_endswith(string,string)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringEndswith(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_string_endswith(string,string)bool'] | undefined]> + + /** + * Calls the verify_string_join(string,string)string ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyStringJoin(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_string_join(string,string)string'] | undefined]> + + /** + * Calls the verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyLog(params?: CallParams): PrimitiveOpsContractComposer<[...TReturns, PrimitiveOpsContractReturns['verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[],byte[5])void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the PrimitiveOpsContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): PrimitiveOpsContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): PrimitiveOpsContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type PrimitiveOpsContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/SignaturesContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/SignaturesContract.ts new file mode 100644 index 0000000..e810782 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/SignaturesContract.ts @@ -0,0 +1,1203 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"SignaturesContract","structs":{"AnotherStruct":[{"name":"one","type":"uint64"},{"name":"two","type":"string"}],"MyStruct":[{"name":"anotherStruct","type":"AnotherStruct"},{"name":"anotherStructAlias","type":"AnotherStruct"},{"name":"three","type":"uint128"},{"name":"four","type":"uint128"}]},"methods":[{"name":"create","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]},"readonly":false,"events":[],"recommendations":{}},{"name":"sink","args":[{"type":"string","name":"value"},{"type":"uint8[]","name":"arr"},{"type":"byte[4]","name":"fixed_bytes"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"alias","args":[{"type":"string","name":"value"},{"type":"uint8[]","name":"arr"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"with_txn","args":[{"type":"string","name":"value"},{"type":"pay","name":"pay"},{"type":"uint8[]","name":"arr"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"with_asset","args":[{"type":"string","name":"value"},{"type":"asset","name":"asset"},{"type":"uint8[]","name":"arr"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"with_app","args":[{"type":"string","name":"value"},{"type":"application","name":"app"},{"type":"uint64","name":"app_id"},{"type":"uint8[]","name":"arr"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"with_acc","args":[{"type":"string","name":"value"},{"type":"account","name":"acc"},{"type":"uint8[]","name":"arr"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"complex_sig","args":[{"type":"((uint64,string),(uint64,string),uint128,uint128)","struct":"MyStruct","name":"struct1"},{"type":"txn","name":"txn"},{"type":"account","name":"acc"},{"type":"uint8[]","name":"five"}],"returns":{"type":"((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"echo_resource_by_index","args":[{"type":"asset","name":"asset"},{"type":"application","name":"app"},{"type":"account","name":"acc"}],"returns":{"type":"(uint64,uint64,address)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"echo_resource_by_value","args":[{"type":"uint64","name":"asset"},{"type":"uint64","name":"app"},{"type":"address","name":"acc"}],"returns":{"type":"(uint64,uint64,address)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[348,353,547,552],"errorMessage":"account funded"},{"pc":[284],"errorMessage":"application exists"},{"pc":[242],"errorMessage":"asset exists"},{"pc":[639],"errorMessage":"expected account to be passed by index"},{"pc":[693],"errorMessage":"expected account to be passed by value"},{"pc":[280],"errorMessage":"expected app id to match provided app id"},{"pc":[629],"errorMessage":"expected application to be passed by index"},{"pc":[687],"errorMessage":"expected application to be passed by value"},{"pc":[619],"errorMessage":"expected asset to be passed by index"},{"pc":[679],"errorMessage":"expected asset to be passed by value"},{"pc":[138],"errorMessage":"expected global to have app address"},{"pc":[132],"errorMessage":"expected global to have app id"},{"pc":[288],"errorMessage":"expected other app to have same creator"},{"pc":[143,147],"errorMessage":"expected txn to have 0"},{"pc":[392],"errorMessage":"invalid array length header"},{"pc":[400],"errorMessage":"invalid number of bytes for arc4.dynamic_array"},{"pc":[671],"errorMessage":"invalid number of bytes for arc4.static_array"},{"pc":[129,294],"errorMessage":"transaction type is appl"},{"pc":[190],"errorMessage":"transaction type is pay"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 6 123
    bytecblock 0x0000 0x151f7c75 0x0000000000000001 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn OnCompletion
    !
    assert
    txn ApplicationID
    bz main_create_NoOp@13
    pushbytess 0x2e01781e 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 0xd6c2ac7f 0x48142d5e // method "sink(string,uint8[],byte[4])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))", method "echo_resource_by_index(asset,application,account)(uint64,uint64,address)", method "echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)"
    txna ApplicationArgs 0
    match sink sink2 with_txn with_asset with_app with_acc complex_sig echo_resource_by_index echo_resource_by_value
    err

main_create_NoOp@13:
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    pushbytes 0x4c5c61ba // method "create()void"
    txna ApplicationArgs 0
    match create
    err


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create[routing]() -> void:
create:
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_2 // appl
    ==
    assert // transaction type is appl
    // tests/artifacts/Arc4ABIMethod/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // tests/artifacts/Arc4ABIMethod/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // tests/artifacts/Arc4ABIMethod/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // tests/artifacts/Arc4ABIMethod/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    // tests/artifacts/Arc4ABIMethod/contract.py:26
    // @arc4.abimethod(create="require")
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink[routing]() -> void:
sink:
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod(validate_encoding="unsafe_disabled")
    txna ApplicationArgs 2
    txna ApplicationArgs 1
    // tests/artifacts/Arc4ABIMethod/contract.py:40
    // assert value
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // assert arr
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod(validate_encoding="unsafe_disabled")
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink2[routing]() -> void:
sink2:
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // @arc4.abimethod(name="alias")
    txna ApplicationArgs 2
    txna ApplicationArgs 1
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // assert value
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:47
    // assert arr
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // @arc4.abimethod(name="alias")
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_txn[routing]() -> void:
with_txn:
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // @arc4.abimethod
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:51
    // assert value
    uncover 2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:52
    // assert arr
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:53
    // assert pay.group_index == 0
    dup
    gtxns GroupIndex
    !
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:55
    // assert pay.amount == 123
    gtxns Amount
    intc_3 // 123
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // @arc4.abimethod
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_asset[routing]() -> void:
with_asset:
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:59
    // assert value
    uncover 2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:60
    // assert arr
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // assert asset.total == 123
    dup
    asset_params_get AssetTotal
    assert // asset exists
    intc_3 // 123
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:62
    // assert Txn.assets(0) == asset
    txna Assets 0
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // @arc4.abimethod(resource_encoding="index")
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_app[routing]() -> void:
with_app:
    // tests/artifacts/Arc4ABIMethod/contract.py:64
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arc4ABIMethod/contract.py:68
    // assert value
    uncover 3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // assert arr
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:70
    // assert app.id == app_id, "expected app id to match provided app id"
    dig 1
    itob
    b==
    assert // expected app id to match provided app id
    // tests/artifacts/Arc4ABIMethod/contract.py:71
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    dup
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_2 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:73
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:74
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    dig 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:76
    // assert Txn.applications(1) == app
    txna Applications 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:64
    // @arc4.abimethod(resource_encoding="index")
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_acc[routing]() -> void:
with_acc:
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:80
    // assert value
    uncover 2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:81
    // assert arr
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:82
    // assert acc.balance == acc.min_balance + 1234
    dup
    acct_params_get AcctBalance
    assert // account funded
    dig 1
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:84
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // @arc4.abimethod(resource_encoding="index")
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.complex_sig[routing]() -> void:
complex_sig:
    // tests/artifacts/Arc4ABIMethod/contract.py:86
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // five.validate()
    dup
    intc_1 // 0
    extract_uint16 // on error: invalid array length header
    pushint 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for arc4.dynamic_array<arc4.uint8>
    // tests/artifacts/Arc4ABIMethod/contract.py:91
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    pushint 4
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:92-93
    // # struct
    // assert struct1.another_struct.one == 1
    dig 3
    intc_1 // 0
    extract_uint16
    dig 4
    pushint 2
    extract_uint16
    dig 5
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8
    bytec_2 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:92-94
    // # struct
    // assert struct1.another_struct.one == 1
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8
    extract_uint16
    dig 1
    len
    dig 2
    uncover 2
    dig 2
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:94
    // assert struct1.another_struct.two == "2"
    bytec_3 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:95
    // assert struct1.another_struct_alias.one == 1
    dig 6
    len
    dig 7
    uncover 4
    uncover 2
    substring3
    dup
    extract 0 8
    bytec_2 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:95-96
    // assert struct1.another_struct_alias.one == 1
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8
    extract_uint16
    dig 1
    len
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:94
    // assert struct1.another_struct.two == "2"
    bytec_3 // 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:96
    // assert struct1.another_struct_alias.two == "2"
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:97
    // assert struct1.three == 3
    dig 5
    extract 4 16
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:98
    // assert struct1.four == 4
    dig 5
    extract 20 16
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:100-101
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    uncover 4
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:103-104
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:105
    // assert acc.balance == acc.min_balance + 1234
    dig 3
    acct_params_get AcctBalance
    assert // account funded
    uncover 4
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:106
    // assert five[0] == 5
    uncover 2
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:86
    // @arc4.abimethod(resource_encoding="index")
    pushint 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    swap
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.echo_resource_by_index[routing]() -> void:
echo_resource_by_index:
    // tests/artifacts/Arc4ABIMethod/contract.py:110-112
    // @arc4.abimethod(
    //     resource_encoding="index",
    // )
    txna ApplicationArgs 1
    btoi
    txnas Assets
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    btoi
    txnas Accounts
    // tests/artifacts/Arc4ABIMethod/contract.py:116
    // asset_idx = op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arc4ABIMethod/contract.py:117
    // assert asset == Txn.assets(asset_idx), "expected asset to be passed by index"
    txnas Assets
    dig 3
    ==
    assert // expected asset to be passed by index
    // tests/artifacts/Arc4ABIMethod/contract.py:118
    // app_idx = op.btoi(Txn.application_args(2))
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/Arc4ABIMethod/contract.py:119
    // assert app == Txn.applications(app_idx), "expected application to be passed by index"
    txnas Applications
    dig 2
    ==
    assert // expected application to be passed by index
    // tests/artifacts/Arc4ABIMethod/contract.py:120
    // acc_idx = op.btoi(Txn.application_args(3))
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/Arc4ABIMethod/contract.py:121
    // assert acc == Txn.accounts(acc_idx), "expected account to be passed by index"
    txnas Accounts
    dig 1
    ==
    assert // expected account to be passed by index
    // tests/artifacts/Arc4ABIMethod/contract.py:110-112
    // @arc4.abimethod(
    //     resource_encoding="index",
    // )
    uncover 2
    itob
    uncover 2
    itob
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.echo_resource_by_value[routing]() -> void:
echo_resource_by_value:
    // tests/artifacts/Arc4ABIMethod/contract.py:124-126
    // @arc4.abimethod(
    //     resource_encoding="value",
    // )
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:130
    // acc.validate()
    dup
    len
    pushint 32
    ==
    assert // invalid number of bytes for arc4.static_array<arc4.uint8, 32>
    // tests/artifacts/Arc4ABIMethod/contract.py:131
    // asset_id = op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arc4ABIMethod/contract.py:132
    // assert asset.id == asset_id, "expected asset to be passed by value"
    dig 3
    ==
    assert // expected asset to be passed by value
    // tests/artifacts/Arc4ABIMethod/contract.py:133
    // app_id = op.btoi(Txn.application_args(2))
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/Arc4ABIMethod/contract.py:134
    // assert app.id == app_id, "expected application to be passed by value"
    dig 2
    ==
    assert // expected application to be passed by value
    // tests/artifacts/Arc4ABIMethod/contract.py:136
    // assert acc.bytes == address, "expected account to be passed by value"
    dup
    // tests/artifacts/Arc4ABIMethod/contract.py:135
    // address = Txn.application_args(3)
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:136
    // assert acc.bytes == address, "expected account to be passed by value"
    ==
    assert // expected account to be passed by value
    // tests/artifacts/Arc4ABIMethod/contract.py:124-126
    // @arc4.abimethod(
    //     resource_encoding="value",
    // )
    uncover 2
    itob
    uncover 2
    itob
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyAEAQAGeyYEAgAABBUffHUIAAAAAAAAAAEDAAEyMRkURDEYQQBHggkELgF4HgQ7Bc8XBAZY3MMEW2RH3gQGH053BOqokTkEUQ5ypATWwqx/BEgULV42GgCOCQApADcARQBuAJAA2AEJAeMCIgCABExcYbo2GgCOAQABACM4ECQSRDIIRDIKMgMTRCM4GBREMRgURCJDNhoCNhoBKBNEKBNEIkM2GgI2GgEoE0QoE0QiQzYaATEWIglJOBAiEkQ2GgJPAigTRCgTREk4FhREMRYiEkQ4CCUSRCJDNhoBNhoCF8AwNhoDTwIoE0QoE0RJcQBEJRJENjAAEkQiQzYaATYaAhfAMjYaAzYaBE8DKBNEKBNESwEWqERJcgdEMgkSRCM4ECQSRCNJwjIyCBJENjIAMggSRCMiwjJLARJENjIBEkQiQzYaATYaAhfAHDYaA08CKBNEKBNESXMAREsBcwFEgdIJCBJENhwAMQASRDYcARJEIkM2GgExFiIJNhoCF8AcNhoDSSNZgQIISwEVEkQxG4EEEkRLAyNZSwSBAllLBU8CSwJSSVcACCqoREmBCFlLARVLAk8CSwJSKxJESwYVSwdPBE8CUklXAAgqqERJgQhZSwEVUisSREsFVwQQgBAAAAAAAAAAAAAAAAAAAAADqERLBVcUEIAQAAAAAAAAAAAAAAAAAAAABKhETwQ4FjEWIgkSRDYaAoABARJESwNzAERPBHMBRIHSCQgSRE8CVwIBgAEFqESBBAgWVwYCgAIABExQTFBMUClMULAiQzYaARfAMDYaAhfAMjYaAxfAHDYaARfAMEsDEkQ2GgIXwDJLAhJENhoDF8AcSwESRE8CFk8CFlBMUClMULAiQzYaARc2GgIXNhoDSRWBIBJENhoBF0sDEkQ2GgIXSwISREk2GgMSRE8CFk8CFlBMUClMULAiQw==","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +// Type definitions for ARC-56 structs + +export type AnotherStruct = { + one: bigint, + two: string +} + + +/** + * Converts the ABI tuple representation of a AnotherStruct to the struct representation + */ +export function AnotherStructFromTuple(abiTuple: [bigint, string]) { + const abiStructType = ABIStructType.fromStruct('AnotherStruct', APP_SPEC.structs) + return getStructValueFromTupleValue(abiStructType, abiTuple) as AnotherStruct +} + +export type MyStruct = { + anotherStruct: AnotherStruct, + anotherStructAlias: AnotherStruct, + three: bigint, + four: bigint +} + + +/** + * Converts the ABI tuple representation of a MyStruct to the struct representation + */ +export function MyStructFromTuple(abiTuple: [AnotherStruct, AnotherStruct, bigint, bigint]) { + const abiStructType = ABIStructType.fromStruct('MyStruct', APP_SPEC.structs) + return getStructValueFromTupleValue(abiStructType, abiTuple) as MyStruct +} + +/** + * The argument types for the SignaturesContract contract + */ +export type SignaturesContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'create()void': Record + 'sink(string,uint8[],byte[4])void': { + value: string + arr: bigint[] | number[] + fixedBytes: Uint8Array + } + 'alias(string,uint8[])void': { + value: string + arr: bigint[] | number[] + } + 'with_txn(string,pay,uint8[])void': { + value: string + pay: AppMethodCallTransactionArgument + arr: bigint[] | number[] + } + 'with_asset(string,asset,uint8[])void': { + value: string + asset: bigint + arr: bigint[] | number[] + } + 'with_app(string,application,uint64,uint8[])void': { + value: string + app: bigint + appId: bigint | number + arr: bigint[] | number[] + } + 'with_acc(string,account,uint8[])void': { + value: string + acc: Uint8Array | string + arr: bigint[] | number[] + } + 'complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))': { + struct1: MyStruct + txn: AppMethodCallTransactionArgument + acc: Uint8Array | string + five: bigint[] | number[] + } + 'echo_resource_by_index(asset,application,account)(uint64,uint64,address)': { + asset: bigint + app: bigint + acc: Uint8Array | string + } + 'echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)': { + asset: bigint | number + app: bigint | number + acc: string + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'create()void': [] + 'sink(string,uint8[],byte[4])void': [value: string, arr: bigint[] | number[], fixedBytes: Uint8Array] + 'alias(string,uint8[])void': [value: string, arr: bigint[] | number[]] + 'with_txn(string,pay,uint8[])void': [value: string, pay: AppMethodCallTransactionArgument, arr: bigint[] | number[]] + 'with_asset(string,asset,uint8[])void': [value: string, asset: bigint, arr: bigint[] | number[]] + 'with_app(string,application,uint64,uint8[])void': [value: string, app: bigint, appId: bigint | number, arr: bigint[] | number[]] + 'with_acc(string,account,uint8[])void': [value: string, acc: Uint8Array | string, arr: bigint[] | number[]] + 'complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))': [struct1: MyStruct, txn: AppMethodCallTransactionArgument, acc: Uint8Array | string, five: bigint[] | number[]] + 'echo_resource_by_index(asset,application,account)(uint64,uint64,address)': [asset: bigint, app: bigint, acc: Uint8Array | string] + 'echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)': [asset: bigint | number, app: bigint | number, acc: string] + } +} + +/** + * The return type for each method + */ +export type SignaturesContractReturns = { + 'create()void': void + 'sink(string,uint8[],byte[4])void': void + 'alias(string,uint8[])void': void + 'with_txn(string,pay,uint8[])void': void + 'with_asset(string,asset,uint8[])void': void + 'with_app(string,application,uint64,uint8[])void': void + 'with_acc(string,account,uint8[])void': void + 'complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))': [[bigint, string], [[bigint, string], [bigint, string], bigint, bigint]] + 'echo_resource_by_index(asset,application,account)(uint64,uint64,address)': [bigint, bigint, string] + 'echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)': [bigint, bigint, string] +} + +/** + * Defines the types of available calls and state of the SignaturesContract smart contract. + */ +export type SignaturesContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'create()void' | 'create', { + argsObj: SignaturesContractArgs['obj']['create()void'] + argsTuple: SignaturesContractArgs['tuple']['create()void'] + returns: SignaturesContractReturns['create()void'] + }> + & Record<'sink(string,uint8[],byte[4])void' | 'sink', { + argsObj: SignaturesContractArgs['obj']['sink(string,uint8[],byte[4])void'] + argsTuple: SignaturesContractArgs['tuple']['sink(string,uint8[],byte[4])void'] + returns: SignaturesContractReturns['sink(string,uint8[],byte[4])void'] + }> + & Record<'alias(string,uint8[])void' | 'alias', { + argsObj: SignaturesContractArgs['obj']['alias(string,uint8[])void'] + argsTuple: SignaturesContractArgs['tuple']['alias(string,uint8[])void'] + returns: SignaturesContractReturns['alias(string,uint8[])void'] + }> + & Record<'with_txn(string,pay,uint8[])void' | 'with_txn', { + argsObj: SignaturesContractArgs['obj']['with_txn(string,pay,uint8[])void'] + argsTuple: SignaturesContractArgs['tuple']['with_txn(string,pay,uint8[])void'] + returns: SignaturesContractReturns['with_txn(string,pay,uint8[])void'] + }> + & Record<'with_asset(string,asset,uint8[])void' | 'with_asset', { + argsObj: SignaturesContractArgs['obj']['with_asset(string,asset,uint8[])void'] + argsTuple: SignaturesContractArgs['tuple']['with_asset(string,asset,uint8[])void'] + returns: SignaturesContractReturns['with_asset(string,asset,uint8[])void'] + }> + & Record<'with_app(string,application,uint64,uint8[])void' | 'with_app', { + argsObj: SignaturesContractArgs['obj']['with_app(string,application,uint64,uint8[])void'] + argsTuple: SignaturesContractArgs['tuple']['with_app(string,application,uint64,uint8[])void'] + returns: SignaturesContractReturns['with_app(string,application,uint64,uint8[])void'] + }> + & Record<'with_acc(string,account,uint8[])void' | 'with_acc', { + argsObj: SignaturesContractArgs['obj']['with_acc(string,account,uint8[])void'] + argsTuple: SignaturesContractArgs['tuple']['with_acc(string,account,uint8[])void'] + returns: SignaturesContractReturns['with_acc(string,account,uint8[])void'] + }> + & Record<'complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))' | 'complex_sig', { + argsObj: SignaturesContractArgs['obj']['complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))'] + argsTuple: SignaturesContractArgs['tuple']['complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))'] + returns: SignaturesContractReturns['complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))'] + }> + & Record<'echo_resource_by_index(asset,application,account)(uint64,uint64,address)' | 'echo_resource_by_index', { + argsObj: SignaturesContractArgs['obj']['echo_resource_by_index(asset,application,account)(uint64,uint64,address)'] + argsTuple: SignaturesContractArgs['tuple']['echo_resource_by_index(asset,application,account)(uint64,uint64,address)'] + returns: SignaturesContractReturns['echo_resource_by_index(asset,application,account)(uint64,uint64,address)'] + }> + & Record<'echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)' | 'echo_resource_by_value', { + argsObj: SignaturesContractArgs['obj']['echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)'] + argsTuple: SignaturesContractArgs['tuple']['echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)'] + returns: SignaturesContractReturns['echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type SignaturesContractSignatures = keyof SignaturesContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type SignaturesContractNonVoidMethodSignatures = keyof SignaturesContractTypes['methods'] extends infer T ? T extends keyof SignaturesContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the SignaturesContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = SignaturesContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the SignaturesContract smart contract to the method's return type + */ +export type MethodReturn = SignaturesContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type SignaturesContractCreateCallParams = + | Expand & {method: 'create'} & { onComplete?: OnApplicationComplete.NoOp } & CreateSchema> + | Expand & {method: 'create()void'} & { onComplete?: OnApplicationComplete.NoOp } & CreateSchema> +/** + * Defines arguments required for the deploy method. + */ +export type SignaturesContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: SignaturesContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the SignaturesContract smart contract + */ +export abstract class SignaturesContractParamsFactory { + /** + * Gets available create ABI call param factories + */ + static get create() { + return { + _resolveByMethod(params: TParams) { + switch(params.method) { + case 'create': + case 'create()void': + return SignaturesContractParamsFactory.create.create(params) + } + throw new Error(`Unknown ' + verb + ' method`) + }, + + /** + * Constructs create ABI call params for the SignaturesContract smart contract using the create()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + create(params: CallParams & AppClientCompilationParams & { onComplete?: OnApplicationComplete.NoOp }): AppClientMethodCallParams & AppClientCompilationParams & { onComplete?: OnApplicationComplete.NoOp } { + return { + ...params, + method: 'create()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + }, + } + } + + /** + * Constructs a no op call for the sink(string,uint8[],byte[4])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static sink(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'sink(string,uint8[],byte[4])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value, params.args.arr, params.args.fixedBytes], + } + } + /** + * Constructs a no op call for the alias(string,uint8[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static alias(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'alias(string,uint8[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value, params.args.arr], + } + } + /** + * Constructs a no op call for the with_txn(string,pay,uint8[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static withTxn(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'with_txn(string,pay,uint8[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value, params.args.pay, params.args.arr], + } + } + /** + * Constructs a no op call for the with_asset(string,asset,uint8[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static withAsset(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'with_asset(string,asset,uint8[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value, params.args.asset, params.args.arr], + } + } + /** + * Constructs a no op call for the with_app(string,application,uint64,uint8[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static withApp(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'with_app(string,application,uint64,uint8[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value, params.args.app, params.args.appId, params.args.arr], + } + } + /** + * Constructs a no op call for the with_acc(string,account,uint8[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static withAcc(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'with_acc(string,account,uint8[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.value, params.args.acc, params.args.arr], + } + } + /** + * Constructs a no op call for the complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128)) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static complexSig(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))' as const, + args: Array.isArray(params.args) ? params.args : [params.args.struct1, params.args.txn, params.args.acc, params.args.five], + } + } + /** + * Constructs a no op call for the echo_resource_by_index(asset,application,account)(uint64,uint64,address) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static echoResourceByIndex(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'echo_resource_by_index(asset,application,account)(uint64,uint64,address)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.asset, params.args.app, params.args.acc], + } + } + /** + * Constructs a no op call for the echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static echoResourceByValue(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.asset, params.args.app, params.args.acc], + } + } +} + +/** + * A factory to create and deploy one or more instance of the SignaturesContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class SignaturesContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `SignaturesContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new SignaturesContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new SignaturesContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the SignaturesContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: SignaturesContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + createParams: params.createParams?.method ? SignaturesContractParamsFactory.create._resolveByMethod(params.createParams) : params.createParams ? params.createParams as (SignaturesContractCreateCallParams & { args: Uint8Array[] }) : undefined, + }) + return { result: result.result, appClient: new SignaturesContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the SignaturesContract smart contract using the create()void ABI method. + * + * @param params The params for the smart contract call + * @returns The create params + */ + create: (params: CallParams & AppClientCompilationParams & CreateSchema & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appFactory.params.create(SignaturesContractParamsFactory.create.create(params)) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the SignaturesContract smart contract using the create()void ABI method. + * + * @param params The params for the smart contract call + * @returns The create transaction + */ + create: (params: CallParams & AppClientCompilationParams & CreateSchema & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appFactory.createTransaction.create(SignaturesContractParamsFactory.create.create(params)) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the SignaturesContract smart contract using an ABI method call using the create()void ABI method. + * + * @param params The params for the smart contract call + * @returns The create result + */ + create: async (params: CallParams & AppClientCompilationParams & CreateSchema & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appFactory.send.create(SignaturesContractParamsFactory.create.create(params)) + return { result: { ...result.result, return: result.result.return as unknown as (undefined | SignaturesContractReturns['create()void']) }, appClient: new SignaturesContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the SignaturesContract smart contract + */ +export class SignaturesContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `SignaturesContractClient` + * + * @param appClient An `AppClient` instance which has been created with the SignaturesContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `SignaturesContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `SignaturesContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new SignaturesContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `SignaturesContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new SignaturesContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the SignaturesContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `sink(string,uint8[],byte[4])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + sink: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.sink(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `alias(string,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + alias: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.alias(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_txn(string,pay,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + withTxn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.withTxn(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_asset(string,asset,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + withAsset: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.withAsset(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_app(string,application,uint64,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + withApp: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.withApp(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_acc(string,account,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + withAcc: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.withAcc(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + complexSig: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.complexSig(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `echo_resource_by_index(asset,application,account)(uint64,uint64,address)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + echoResourceByIndex: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.echoResourceByIndex(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + echoResourceByValue: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(SignaturesContractParamsFactory.echoResourceByValue(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the SignaturesContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `sink(string,uint8[],byte[4])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + sink: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.sink(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `alias(string,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + alias: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.alias(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_txn(string,pay,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + withTxn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.withTxn(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_asset(string,asset,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + withAsset: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.withAsset(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_app(string,application,uint64,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + withApp: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.withApp(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_acc(string,account,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + withAcc: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.withAcc(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + complexSig: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.complexSig(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `echo_resource_by_index(asset,application,account)(uint64,uint64,address)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + echoResourceByIndex: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.echoResourceByIndex(params)) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + echoResourceByValue: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(SignaturesContractParamsFactory.echoResourceByValue(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the SignaturesContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `sink(string,uint8[],byte[4])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + sink: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.sink(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['sink(string,uint8[],byte[4])void'])} + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `alias(string,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + alias: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.alias(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['alias(string,uint8[])void'])} + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_txn(string,pay,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + withTxn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.withTxn(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['with_txn(string,pay,uint8[])void'])} + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_asset(string,asset,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + withAsset: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.withAsset(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['with_asset(string,asset,uint8[])void'])} + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_app(string,application,uint64,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + withApp: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.withApp(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['with_app(string,application,uint64,uint8[])void'])} + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `with_acc(string,account,uint8[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + withAcc: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.withAcc(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['with_acc(string,account,uint8[])void'])} + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + complexSig: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.complexSig(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))'])} + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `echo_resource_by_index(asset,application,account)(uint64,uint64,address)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + echoResourceByIndex: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.echoResourceByIndex(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['echo_resource_by_index(asset,application,account)(uint64,uint64,address)'])} + }, + + /** + * Makes a call to the SignaturesContract smart contract using the `echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + echoResourceByValue: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(SignaturesContractParamsFactory.echoResourceByValue(params)) + return {...result, return: result.return as unknown as (undefined | SignaturesContractReturns['echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new SignaturesContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current SignaturesContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): SignaturesContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a sink(string,uint8[],byte[4])void method call against the SignaturesContract contract + */ + sink(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.sink(params))) + return this + }, + /** + * Add a alias(string,uint8[])void method call against the SignaturesContract contract + */ + alias(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.alias(params))) + return this + }, + /** + * Add a with_txn(string,pay,uint8[])void method call against the SignaturesContract contract + */ + withTxn(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.withTxn(params))) + return this + }, + /** + * Add a with_asset(string,asset,uint8[])void method call against the SignaturesContract contract + */ + withAsset(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.withAsset(params))) + return this + }, + /** + * Add a with_app(string,application,uint64,uint8[])void method call against the SignaturesContract contract + */ + withApp(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.withApp(params))) + return this + }, + /** + * Add a with_acc(string,account,uint8[])void method call against the SignaturesContract contract + */ + withAcc(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.withAcc(params))) + return this + }, + /** + * Add a complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128)) method call against the SignaturesContract contract + */ + complexSig(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.complexSig(params))) + return this + }, + /** + * Add a echo_resource_by_index(asset,application,account)(uint64,uint64,address) method call against the SignaturesContract contract + */ + echoResourceByIndex(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.echoResourceByIndex(params))) + return this + }, + /** + * Add a echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address) method call against the SignaturesContract contract + */ + echoResourceByValue(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.echoResourceByValue(params))) + return this + }, + /** + * Add a clear state call to the SignaturesContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as SignaturesContractComposer + } +} +export type SignaturesContractComposer = { + /** + * Calls the sink(string,uint8[],byte[4])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + sink(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['sink(string,uint8[],byte[4])void'] | undefined]> + + /** + * Calls the alias(string,uint8[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + alias(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['alias(string,uint8[])void'] | undefined]> + + /** + * Calls the with_txn(string,pay,uint8[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + withTxn(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['with_txn(string,pay,uint8[])void'] | undefined]> + + /** + * Calls the with_asset(string,asset,uint8[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + withAsset(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['with_asset(string,asset,uint8[])void'] | undefined]> + + /** + * Calls the with_app(string,application,uint64,uint8[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + withApp(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['with_app(string,application,uint64,uint8[])void'] | undefined]> + + /** + * Calls the with_acc(string,account,uint8[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + withAcc(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['with_acc(string,account,uint8[])void'] | undefined]> + + /** + * Calls the complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128)) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + complexSig(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))'] | undefined]> + + /** + * Calls the echo_resource_by_index(asset,application,account)(uint64,uint64,address) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + echoResourceByIndex(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['echo_resource_by_index(asset,application,account)(uint64,uint64,address)'] | undefined]> + + /** + * Calls the echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + echoResourceByValue(params?: CallParams): SignaturesContractComposer<[...TReturns, SignaturesContractReturns['echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the SignaturesContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): SignaturesContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): SignaturesContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type SignaturesContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAcctParamsGet.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAcctParamsGet.ts new file mode 100644 index 0000000..62c4b5b --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAcctParamsGet.ts @@ -0,0 +1,1319 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"arcs":[],"name":"StateAcctParamsGet","structs":{},"methods":[{"name":"verify_acct_balance","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_min_balance","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_auth_addr","args":[{"name":"a","type":"account"}],"returns":{"type":"byte[]"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_num_uint","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_num_byte_slice","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_extra_app_pages","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_apps_created","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_apps_opted_in","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_assets_created","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_assets","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_boxes","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}},{"name":"verify_acct_total_box_bytes","args":[{"name":"a","type":"account"}],"returns":{"type":"uint64"},"events":[],"actions":{"create":[],"call":["NoOp"]}}],"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"source":{"approval":"#pragma version 10

tests.artifacts.StateOps.contract.StateAcctParamsGet.approval_program:
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@16
    method "verify_acct_balance(account)uint64"
    method "verify_acct_min_balance(account)uint64"
    method "verify_acct_auth_addr(account)byte[]"
    method "verify_acct_total_num_uint(account)uint64"
    method "verify_acct_total_num_byte_slice(account)uint64"
    method "verify_acct_total_extra_app_pages(account)uint64"
    method "verify_acct_total_apps_created(account)uint64"
    method "verify_acct_total_apps_opted_in(account)uint64"
    method "verify_acct_total_assets_created(account)uint64"
    method "verify_acct_total_assets(account)uint64"
    method "verify_acct_total_boxes(account)uint64"
    method "verify_acct_total_box_bytes(account)uint64"
    txna ApplicationArgs 0
    match main_verify_acct_balance_route@2 main_verify_acct_min_balance_route@3 main_verify_acct_auth_addr_route@4 main_verify_acct_total_num_uint_route@5 main_verify_acct_total_num_byte_slice_route@6 main_verify_acct_total_extra_app_pages_route@7 main_verify_acct_total_apps_created_route@8 main_verify_acct_total_apps_opted_in_route@9 main_verify_acct_total_assets_created_route@10 main_verify_acct_total_assets_route@11 main_verify_acct_total_boxes_route@12 main_verify_acct_total_box_bytes_route@13
    err // reject transaction

main_verify_acct_balance_route@2:
    // tests/artifacts/StateOps/contract.py:18
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:18
    // @arc4.abimethod()
    callsub verify_acct_balance
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_min_balance_route@3:
    // tests/artifacts/StateOps/contract.py:23
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:23
    // @arc4.abimethod()
    callsub verify_acct_min_balance
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_auth_addr_route@4:
    // tests/artifacts/StateOps/contract.py:28
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:28
    // @arc4.abimethod()
    callsub verify_acct_auth_addr
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_num_uint_route@5:
    // tests/artifacts/StateOps/contract.py:33
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:33
    // @arc4.abimethod()
    callsub verify_acct_total_num_uint
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_num_byte_slice_route@6:
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    callsub verify_acct_total_num_byte_slice
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_extra_app_pages_route@7:
    // tests/artifacts/StateOps/contract.py:43
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:43
    // @arc4.abimethod()
    callsub verify_acct_total_extra_app_pages
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_apps_created_route@8:
    // tests/artifacts/StateOps/contract.py:48
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:48
    // @arc4.abimethod()
    callsub verify_acct_total_apps_created
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_apps_opted_in_route@9:
    // tests/artifacts/StateOps/contract.py:53
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:53
    // @arc4.abimethod()
    callsub verify_acct_total_apps_opted_in
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_assets_created_route@10:
    // tests/artifacts/StateOps/contract.py:58
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:58
    // @arc4.abimethod()
    callsub verify_acct_total_assets_created
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_assets_route@11:
    // tests/artifacts/StateOps/contract.py:63
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:63
    // @arc4.abimethod()
    callsub verify_acct_total_assets
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_boxes_route@12:
    // tests/artifacts/StateOps/contract.py:68
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:68
    // @arc4.abimethod()
    callsub verify_acct_total_boxes
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_box_bytes_route@13:
    // tests/artifacts/StateOps/contract.py:73
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:73
    // @arc4.abimethod()
    callsub verify_acct_total_box_bytes
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_bare_routing@16:
    // tests/artifacts/StateOps/contract.py:17
    // class StateAcctParamsGet(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_balance(a: bytes) -> uint64:
verify_acct_balance:
    // tests/artifacts/StateOps/contract.py:18-19
    // @arc4.abimethod()
    // def verify_acct_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:20
    // balance, _val = op.AcctParamsGet.acct_balance(a)
    frame_dig -1
    acct_params_get AcctBalance
    pop
    // tests/artifacts/StateOps/contract.py:21
    // return balance
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_min_balance(a: bytes) -> uint64:
verify_acct_min_balance:
    // tests/artifacts/StateOps/contract.py:23-24
    // @arc4.abimethod()
    // def verify_acct_min_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:25
    // min_balance, _val = op.AcctParamsGet.acct_min_balance(a)
    frame_dig -1
    acct_params_get AcctMinBalance
    pop
    // tests/artifacts/StateOps/contract.py:26
    // return min_balance
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_auth_addr(a: bytes) -> bytes:
verify_acct_auth_addr:
    // tests/artifacts/StateOps/contract.py:28-29
    // @arc4.abimethod()
    // def verify_acct_auth_addr(self, a: algopy.Account) -> algopy.Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:30
    // auth_addr, _val = op.AcctParamsGet.acct_auth_addr(a)
    frame_dig -1
    acct_params_get AcctAuthAddr
    pop
    // tests/artifacts/StateOps/contract.py:31
    // return auth_addr.bytes
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_num_uint(a: bytes) -> uint64:
verify_acct_total_num_uint:
    // tests/artifacts/StateOps/contract.py:33-34
    // @arc4.abimethod()
    // def verify_acct_total_num_uint(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:35
    // total_num_uint, _val = op.AcctParamsGet.acct_total_num_uint(a)
    frame_dig -1
    acct_params_get AcctTotalNumUint
    pop
    // tests/artifacts/StateOps/contract.py:36
    // return total_num_uint
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_num_byte_slice(a: bytes) -> uint64:
verify_acct_total_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:38-39
    // @arc4.abimethod()
    // def verify_acct_total_num_byte_slice(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:40
    // total_num_byte_slice, _val = op.AcctParamsGet.acct_total_num_byte_slice(a)
    frame_dig -1
    acct_params_get AcctTotalNumByteSlice
    pop
    // tests/artifacts/StateOps/contract.py:41
    // return total_num_byte_slice
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_extra_app_pages(a: bytes) -> uint64:
verify_acct_total_extra_app_pages:
    // tests/artifacts/StateOps/contract.py:43-44
    // @arc4.abimethod()
    // def verify_acct_total_extra_app_pages(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:45
    // total_extra_app_pages, _val = op.AcctParamsGet.acct_total_extra_app_pages(a)
    frame_dig -1
    acct_params_get AcctTotalExtraAppPages
    pop
    // tests/artifacts/StateOps/contract.py:46
    // return total_extra_app_pages
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_apps_created(a: bytes) -> uint64:
verify_acct_total_apps_created:
    // tests/artifacts/StateOps/contract.py:48-49
    // @arc4.abimethod()
    // def verify_acct_total_apps_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:50
    // total_apps_created, _val = op.AcctParamsGet.acct_total_apps_created(a)
    frame_dig -1
    acct_params_get AcctTotalAppsCreated
    pop
    // tests/artifacts/StateOps/contract.py:51
    // return total_apps_created
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_apps_opted_in(a: bytes) -> uint64:
verify_acct_total_apps_opted_in:
    // tests/artifacts/StateOps/contract.py:53-54
    // @arc4.abimethod()
    // def verify_acct_total_apps_opted_in(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:55
    // total_apps_opted_in, _val = op.AcctParamsGet.acct_total_apps_opted_in(a)
    frame_dig -1
    acct_params_get AcctTotalAppsOptedIn
    pop
    // tests/artifacts/StateOps/contract.py:56
    // return total_apps_opted_in
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_assets_created(a: bytes) -> uint64:
verify_acct_total_assets_created:
    // tests/artifacts/StateOps/contract.py:58-59
    // @arc4.abimethod()
    // def verify_acct_total_assets_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:60
    // total_assets_created, _val = op.AcctParamsGet.acct_total_assets_created(a)
    frame_dig -1
    acct_params_get AcctTotalAssetsCreated
    pop
    // tests/artifacts/StateOps/contract.py:61
    // return total_assets_created
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_assets(a: bytes) -> uint64:
verify_acct_total_assets:
    // tests/artifacts/StateOps/contract.py:63-64
    // @arc4.abimethod()
    // def verify_acct_total_assets(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:65
    // total_assets, _val = op.AcctParamsGet.acct_total_assets(a)
    frame_dig -1
    acct_params_get AcctTotalAssets
    pop
    // tests/artifacts/StateOps/contract.py:66
    // return total_assets
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_boxes(a: bytes) -> uint64:
verify_acct_total_boxes:
    // tests/artifacts/StateOps/contract.py:68-69
    // @arc4.abimethod()
    // def verify_acct_total_boxes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:70
    // total_boxes, _val = op.AcctParamsGet.acct_total_boxes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxes
    pop
    // tests/artifacts/StateOps/contract.py:71
    // return total_boxes
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGet.verify_acct_total_box_bytes(a: bytes) -> uint64:
verify_acct_total_box_bytes:
    // tests/artifacts/StateOps/contract.py:73-74
    // @arc4.abimethod()
    // def verify_acct_total_box_bytes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:75
    // total_box_bytes, _val = op.AcctParamsGet.acct_total_box_bytes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxBytes
    pop
    // tests/artifacts/StateOps/contract.py:76
    // return total_box_bytes
    retsub
","clear":"I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBY2N0UGFyYW1zR2V0LmNsZWFyX3N0YXRlX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6MTcKICAgIC8vIGNsYXNzIFN0YXRlQWNjdFBhcmFtc0dldChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="},"bareActions":{"create":["NoOp"],"call":[]}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAcctParamsGet contract + */ +export type StateAcctParamsGetArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_acct_balance(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_min_balance(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_auth_addr(account)byte[]': { + a: Uint8Array | string + } + 'verify_acct_total_num_uint(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_num_byte_slice(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_extra_app_pages(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_apps_created(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_apps_opted_in(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_assets_created(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_assets(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_boxes(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_box_bytes(account)uint64': { + a: Uint8Array | string + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_acct_balance(account)uint64': [a: Uint8Array | string] + 'verify_acct_min_balance(account)uint64': [a: Uint8Array | string] + 'verify_acct_auth_addr(account)byte[]': [a: Uint8Array | string] + 'verify_acct_total_num_uint(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_num_byte_slice(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_extra_app_pages(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_apps_created(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_apps_opted_in(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_assets_created(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_assets(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_boxes(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_box_bytes(account)uint64': [a: Uint8Array | string] + } +} + +/** + * The return type for each method + */ +export type StateAcctParamsGetReturns = { + 'verify_acct_balance(account)uint64': bigint + 'verify_acct_min_balance(account)uint64': bigint + 'verify_acct_auth_addr(account)byte[]': Uint8Array + 'verify_acct_total_num_uint(account)uint64': bigint + 'verify_acct_total_num_byte_slice(account)uint64': bigint + 'verify_acct_total_extra_app_pages(account)uint64': bigint + 'verify_acct_total_apps_created(account)uint64': bigint + 'verify_acct_total_apps_opted_in(account)uint64': bigint + 'verify_acct_total_assets_created(account)uint64': bigint + 'verify_acct_total_assets(account)uint64': bigint + 'verify_acct_total_boxes(account)uint64': bigint + 'verify_acct_total_box_bytes(account)uint64': bigint +} + +/** + * Defines the types of available calls and state of the StateAcctParamsGet smart contract. + */ +export type StateAcctParamsGetTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_acct_balance(account)uint64' | 'verify_acct_balance', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_balance(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_balance(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_balance(account)uint64'] + }> + & Record<'verify_acct_min_balance(account)uint64' | 'verify_acct_min_balance', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_min_balance(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_min_balance(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_min_balance(account)uint64'] + }> + & Record<'verify_acct_auth_addr(account)byte[]' | 'verify_acct_auth_addr', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_auth_addr(account)byte[]'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_auth_addr(account)byte[]'] + returns: StateAcctParamsGetReturns['verify_acct_auth_addr(account)byte[]'] + }> + & Record<'verify_acct_total_num_uint(account)uint64' | 'verify_acct_total_num_uint', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_num_uint(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_num_uint(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_num_uint(account)uint64'] + }> + & Record<'verify_acct_total_num_byte_slice(account)uint64' | 'verify_acct_total_num_byte_slice', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_num_byte_slice(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_num_byte_slice(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_num_byte_slice(account)uint64'] + }> + & Record<'verify_acct_total_extra_app_pages(account)uint64' | 'verify_acct_total_extra_app_pages', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_extra_app_pages(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_extra_app_pages(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_extra_app_pages(account)uint64'] + }> + & Record<'verify_acct_total_apps_created(account)uint64' | 'verify_acct_total_apps_created', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_apps_created(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_apps_created(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_apps_created(account)uint64'] + }> + & Record<'verify_acct_total_apps_opted_in(account)uint64' | 'verify_acct_total_apps_opted_in', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_apps_opted_in(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_apps_opted_in(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_apps_opted_in(account)uint64'] + }> + & Record<'verify_acct_total_assets_created(account)uint64' | 'verify_acct_total_assets_created', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_assets_created(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_assets_created(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_assets_created(account)uint64'] + }> + & Record<'verify_acct_total_assets(account)uint64' | 'verify_acct_total_assets', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_assets(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_assets(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_assets(account)uint64'] + }> + & Record<'verify_acct_total_boxes(account)uint64' | 'verify_acct_total_boxes', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_boxes(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_boxes(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_boxes(account)uint64'] + }> + & Record<'verify_acct_total_box_bytes(account)uint64' | 'verify_acct_total_box_bytes', { + argsObj: StateAcctParamsGetArgs['obj']['verify_acct_total_box_bytes(account)uint64'] + argsTuple: StateAcctParamsGetArgs['tuple']['verify_acct_total_box_bytes(account)uint64'] + returns: StateAcctParamsGetReturns['verify_acct_total_box_bytes(account)uint64'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAcctParamsGetSignatures = keyof StateAcctParamsGetTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StateAcctParamsGetNonVoidMethodSignatures = keyof StateAcctParamsGetTypes['methods'] extends infer T ? T extends keyof StateAcctParamsGetTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAcctParamsGet smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAcctParamsGetTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAcctParamsGet smart contract to the method's return type + */ +export type MethodReturn = StateAcctParamsGetTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAcctParamsGetCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAcctParamsGetDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAcctParamsGetCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAcctParamsGet smart contract + */ +export abstract class StateAcctParamsGetParamsFactory { + /** + * Constructs a no op call for the verify_acct_balance(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctBalance(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_balance(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_min_balance(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctMinBalance(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_min_balance(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_auth_addr(account)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctAuthAddr(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_auth_addr(account)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_num_uint(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalNumUint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_num_uint(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_num_byte_slice(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalNumByteSlice(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_num_byte_slice(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_extra_app_pages(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalExtraAppPages(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_extra_app_pages(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_apps_created(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalAppsCreated(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_apps_created(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_apps_opted_in(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalAppsOptedIn(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_apps_opted_in(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_assets_created(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalAssetsCreated(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_assets_created(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_assets(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalAssets(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_assets(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_boxes(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalBoxes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_boxes(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_box_bytes(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalBoxBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_box_bytes(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StateAcctParamsGet smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAcctParamsGetFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAcctParamsGetFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAcctParamsGetClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAcctParamsGetClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAcctParamsGet smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAcctParamsGetDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAcctParamsGetClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAcctParamsGet smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAcctParamsGet smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAcctParamsGet smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAcctParamsGetClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAcctParamsGet smart contract + */ +export class StateAcctParamsGetClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAcctParamsGetClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAcctParamsGet app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAcctParamsGetClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAcctParamsGetClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAcctParamsGetClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAcctParamsGetClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAcctParamsGetClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the StateAcctParamsGet smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctBalance: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctBalance(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_min_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctMinBalance: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctMinBalance(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_auth_addr(account)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctAuthAddr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctAuthAddr(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_num_uint(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalNumUint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalNumUint(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_num_byte_slice(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalNumByteSlice: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalNumByteSlice(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_extra_app_pages(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalExtraAppPages: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalExtraAppPages(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_apps_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalAppsCreated: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAppsCreated(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_apps_opted_in(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalAppsOptedIn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAppsOptedIn(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_assets_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalAssetsCreated: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAssetsCreated(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_assets(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalAssets: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAssets(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_boxes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalBoxes(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_box_bytes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalBoxBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetParamsFactory.verifyAcctTotalBoxBytes(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the StateAcctParamsGet smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctBalance: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctBalance(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_min_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctMinBalance: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctMinBalance(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_auth_addr(account)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctAuthAddr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctAuthAddr(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_num_uint(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalNumUint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalNumUint(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_num_byte_slice(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalNumByteSlice: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalNumByteSlice(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_extra_app_pages(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalExtraAppPages: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalExtraAppPages(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_apps_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalAppsCreated: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAppsCreated(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_apps_opted_in(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalAppsOptedIn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAppsOptedIn(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_assets_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalAssetsCreated: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAssetsCreated(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_assets(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalAssets: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAssets(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_boxes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalBoxes(params)) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_box_bytes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalBoxBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetParamsFactory.verifyAcctTotalBoxBytes(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the StateAcctParamsGet smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctBalance: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctBalance(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_balance(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_min_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctMinBalance: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctMinBalance(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_min_balance(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_auth_addr(account)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctAuthAddr: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctAuthAddr(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_auth_addr(account)byte[]'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_num_uint(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalNumUint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalNumUint(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_num_uint(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_num_byte_slice(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalNumByteSlice: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalNumByteSlice(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_num_byte_slice(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_extra_app_pages(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalExtraAppPages: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalExtraAppPages(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_extra_app_pages(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_apps_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalAppsCreated: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAppsCreated(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_apps_created(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_apps_opted_in(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalAppsOptedIn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAppsOptedIn(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_apps_opted_in(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_assets_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalAssetsCreated: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAssetsCreated(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_assets_created(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_assets(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalAssets: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalAssets(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_assets(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_boxes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalBoxes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalBoxes(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_boxes(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGet smart contract using the `verify_acct_total_box_bytes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalBoxBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetParamsFactory.verifyAcctTotalBoxBytes(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetReturns['verify_acct_total_box_bytes(account)uint64'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAcctParamsGetClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAcctParamsGet app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAcctParamsGetComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_acct_balance(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctBalance(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctBalance(params))) + return this + }, + /** + * Add a verify_acct_min_balance(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctMinBalance(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctMinBalance(params))) + return this + }, + /** + * Add a verify_acct_auth_addr(account)byte[] method call against the StateAcctParamsGet contract + */ + verifyAcctAuthAddr(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctAuthAddr(params))) + return this + }, + /** + * Add a verify_acct_total_num_uint(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalNumUint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalNumUint(params))) + return this + }, + /** + * Add a verify_acct_total_num_byte_slice(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalNumByteSlice(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalNumByteSlice(params))) + return this + }, + /** + * Add a verify_acct_total_extra_app_pages(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalExtraAppPages(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalExtraAppPages(params))) + return this + }, + /** + * Add a verify_acct_total_apps_created(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalAppsCreated(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalAppsCreated(params))) + return this + }, + /** + * Add a verify_acct_total_apps_opted_in(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalAppsOptedIn(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalAppsOptedIn(params))) + return this + }, + /** + * Add a verify_acct_total_assets_created(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalAssetsCreated(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalAssetsCreated(params))) + return this + }, + /** + * Add a verify_acct_total_assets(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalAssets(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalAssets(params))) + return this + }, + /** + * Add a verify_acct_total_boxes(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalBoxes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalBoxes(params))) + return this + }, + /** + * Add a verify_acct_total_box_bytes(account)uint64 method call against the StateAcctParamsGet contract + */ + verifyAcctTotalBoxBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalBoxBytes(params))) + return this + }, + /** + * Add a clear state call to the StateAcctParamsGet contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAcctParamsGetComposer + } +} +export type StateAcctParamsGetComposer = { + /** + * Calls the verify_acct_balance(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctBalance(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_balance(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_min_balance(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctMinBalance(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_min_balance(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_auth_addr(account)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctAuthAddr(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_auth_addr(account)byte[]'] | undefined]> + + /** + * Calls the verify_acct_total_num_uint(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalNumUint(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_num_uint(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_num_byte_slice(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalNumByteSlice(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_num_byte_slice(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_extra_app_pages(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalExtraAppPages(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_extra_app_pages(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_apps_created(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalAppsCreated(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_apps_created(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_apps_opted_in(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalAppsOptedIn(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_apps_opted_in(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_assets_created(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalAssetsCreated(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_assets_created(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_assets(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalAssets(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_assets(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_boxes(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalBoxes(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_boxes(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_box_bytes(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalBoxBytes(params?: CallParams): StateAcctParamsGetComposer<[...TReturns, StateAcctParamsGetReturns['verify_acct_total_box_bytes(account)uint64'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the StateAcctParamsGet smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAcctParamsGetComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAcctParamsGetComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAcctParamsGetComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAcctParamsGetContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAcctParamsGetContract.ts new file mode 100644 index 0000000..01c1c8f --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAcctParamsGetContract.ts @@ -0,0 +1,1526 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateAcctParamsGetContract","structs":{},"methods":[{"name":"verify_acct_balance","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_min_balance","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_auth_addr","args":[{"type":"account","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_num_uint","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_num_byte_slice","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_extra_app_pages","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_apps_created","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_apps_opted_in","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_assets_created","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_assets","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_boxes","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_total_box_bytes","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_incentive_eligible","args":[{"type":"account","name":"a"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_last_heartbeat","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_acct_last_proposed","args":[{"type":"account","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[171,225],"errorMessage":"account funded"},{"pc":[175],"errorMessage":"expected Account balance to match"},{"pc":[229],"errorMessage":"expected Account min_balance to match"},{"pc":[166,220,273,301,330,359,388,417,446,475,504,533,562,598,627],"errorMessage":"expected funded by index to match"},{"pc":[190],"errorMessage":"expected op.balance by index to match"},{"pc":[181],"errorMessage":"expected op.balance to match"},{"pc":[244],"errorMessage":"expected op.min_balance by index to match"},{"pc":[235],"errorMessage":"expected op.min_balance to match"},{"pc":[164,218,271,299,328,357,386,415,444,473,502,531,560,596,625],"errorMessage":"expected value by index to match"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn NumAppArgs
    bz main___algopy_default_create@22
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x5f5b43e4 0x73dc93c7 0x5626dfeb 0xdc8a25bf 0x198ebd8c 0x2301ab26 0x9f68fca6 0xa975c2d1 0xd1e04801 0xb6966be5 0x195d5418 0x6adae3f1 0xdf8cfee5 0x6ad70d21 0x1735fd22 // method "verify_acct_balance(account)uint64", method "verify_acct_min_balance(account)uint64", method "verify_acct_auth_addr(account)address", method "verify_acct_total_num_uint(account)uint64", method "verify_acct_total_num_byte_slice(account)uint64", method "verify_acct_total_extra_app_pages(account)uint64", method "verify_acct_total_apps_created(account)uint64", method "verify_acct_total_apps_opted_in(account)uint64", method "verify_acct_total_assets_created(account)uint64", method "verify_acct_total_assets(account)uint64", method "verify_acct_total_boxes(account)uint64", method "verify_acct_total_box_bytes(account)uint64", method "verify_acct_incentive_eligible(account)bool", method "verify_acct_last_heartbeat(account)uint64", method "verify_acct_last_proposed(account)uint64"
    txna ApplicationArgs 0
    match verify_acct_balance verify_acct_min_balance verify_acct_auth_addr verify_acct_total_num_uint verify_acct_total_num_byte_slice verify_acct_total_extra_app_pages verify_acct_total_apps_created verify_acct_total_apps_opted_in verify_acct_total_assets_created verify_acct_total_assets verify_acct_total_boxes verify_acct_total_box_bytes verify_acct_incentive_eligible verify_acct_last_heartbeat verify_acct_last_proposed
    err

main___algopy_default_create@22:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_balance[routing]() -> void:
verify_acct_balance:
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:27
    // value, funded = op.AcctParamsGet.acct_balance(a)
    dup
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:28
    // value_index, funded_index = op.AcctParamsGet.acct_balance(_get_1st_ref_index())
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:29
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:30
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:31
    // assert value == a.balance, "expected Account balance to match"
    dig 1
    acct_params_get AcctBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account balance to match
    // tests/artifacts/StateOps/contract.py:32
    // assert value == algopy.op.balance(a), "expected op.balance to match"
    swap
    balance
    dig 1
    ==
    assert // expected op.balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:33-35
    // assert value == algopy.op.balance(
    //     _get_1st_ref_index()
    // ), "expected op.balance by index to match"
    balance
    dig 1
    ==
    assert // expected op.balance by index to match
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_min_balance[routing]() -> void:
verify_acct_min_balance:
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:40
    // value, funded = op.AcctParamsGet.acct_min_balance(a)
    dup
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:41
    // value_index, funded_index = op.AcctParamsGet.acct_min_balance(_get_1st_ref_index())
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:42
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:43
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:44
    // assert value == a.min_balance, "expected Account min_balance to match"
    dig 1
    acct_params_get AcctMinBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account min_balance to match
    // tests/artifacts/StateOps/contract.py:45
    // assert value == algopy.op.min_balance(a), "expected op.min_balance to match"
    swap
    min_balance
    dig 1
    ==
    assert // expected op.min_balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:46-48
    // assert value == algopy.op.min_balance(
    //     _get_1st_ref_index()
    // ), "expected op.min_balance by index to match"
    min_balance
    dig 1
    ==
    assert // expected op.min_balance by index to match
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_auth_addr[routing]() -> void:
verify_acct_auth_addr:
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:53
    // value, funded = op.AcctParamsGet.acct_auth_addr(a)
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:54
    // value_index, funded_index = op.AcctParamsGet.acct_auth_addr(_get_1st_ref_index())
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:55
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:56
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod(resource_encoding="index")
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_uint[routing]() -> void:
verify_acct_total_num_uint:
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:61
    // value, funded = op.AcctParamsGet.acct_total_num_uint(a)
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:62
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_uint(_get_1st_ref_index())
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:63
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:64
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_byte_slice[routing]() -> void:
verify_acct_total_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:69
    // value, funded = op.AcctParamsGet.acct_total_num_byte_slice(a)
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:70-72
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_byte_slice(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:73
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:74
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_extra_app_pages[routing]() -> void:
verify_acct_total_extra_app_pages:
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:79
    // value, funded = op.AcctParamsGet.acct_total_extra_app_pages(a)
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:80-82
    // value_index, funded_index = op.AcctParamsGet.acct_total_extra_app_pages(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:83
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:84
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_created[routing]() -> void:
verify_acct_total_apps_created:
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:89
    // value, funded = op.AcctParamsGet.acct_total_apps_created(a)
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:90
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_created(_get_1st_ref_index())
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:91
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:92
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_opted_in[routing]() -> void:
verify_acct_total_apps_opted_in:
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:97
    // value, funded = op.AcctParamsGet.acct_total_apps_opted_in(a)
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:98
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_opted_in(_get_1st_ref_index())
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:99
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:100
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets_created[routing]() -> void:
verify_acct_total_assets_created:
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:105
    // value, funded = op.AcctParamsGet.acct_total_assets_created(a)
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:106-108
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets_created(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:109
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:110
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets[routing]() -> void:
verify_acct_total_assets:
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:115
    // value, funded = op.AcctParamsGet.acct_total_assets(a)
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:116
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets(_get_1st_ref_index())
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:117
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:118
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_boxes[routing]() -> void:
verify_acct_total_boxes:
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:123
    // value, funded = op.AcctParamsGet.acct_total_boxes(a)
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:124
    // value_index, funded_index = op.AcctParamsGet.acct_total_boxes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:125
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:126
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_box_bytes[routing]() -> void:
verify_acct_total_box_bytes:
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:131
    // value, funded = op.AcctParamsGet.acct_total_box_bytes(a)
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:132
    // value_index, funded_index = op.AcctParamsGet.acct_total_box_bytes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:133
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:134
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_incentive_eligible[routing]() -> void:
verify_acct_incentive_eligible:
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:139
    // value, funded = op.AcctParamsGet.acct_incentive_eligible(a)
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:140
    // value_index, funded_index = op.AcctParamsGet.acct_incentive_eligible(_get_1st_ref_index())
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:141
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:142
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod(resource_encoding="index")
    pushbytes 0x00
    pushint 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_heartbeat[routing]() -> void:
verify_acct_last_heartbeat:
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:147
    // value, funded = op.AcctParamsGet.acct_last_heartbeat(a)
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:148
    // value_index, funded_index = op.AcctParamsGet.acct_last_heartbeat(_get_1st_ref_index())
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:149
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:150
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_proposed[routing]() -> void:
verify_acct_last_proposed:
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod(resource_encoding="index")
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:155
    // value, funded = op.AcctParamsGet.acct_last_proposed(a)
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:156
    // value_index, funded_index = op.AcctParamsGet.acct_last_proposed(_get_1st_ref_index())
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:157
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:158
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod(resource_encoding="index")
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyABASYBBBUffHUxG0EAeDEZFEQxGESCDwRfW0PkBHPck8cEVibf6wTciiW/BBmOvYwEIwGrJgSfaPymBKl1wtEE0eBIAQS2lmvlBBldVBgEatrj8QTfjP7lBGrXDSEEFzX9IjYaAI4PAAkAPwB1AJEArgDLAOgBBQEiAT8BXAF5AZYBugHXADEZFDEYFBBDNhoBF8AcSXMANhoBF3MASwNPAhJEEkRLAXMAREsBEkRMYEsBEkQ2GgEXYEsBEkQWKExQsCJDNhoBF8AcSXMBNhoBF3MBSwNPAhJEEkRLAXMBREsBEkRMeEsBEkQ2GgEXeEsBEkQWKExQsCJDNhoBF8AccwI2GgEXcwJLA08CEkQSRChMULAiQzYaARfAHHMDNhoBF3MDSwNPAhJEEkQWKExQsCJDNhoBF8AccwQ2GgEXcwRLA08CEkQSRBYoTFCwIkM2GgEXwBxzBTYaARdzBUsDTwISRBJEFihMULAiQzYaARfAHHMGNhoBF3MGSwNPAhJEEkQWKExQsCJDNhoBF8Accwc2GgEXcwdLA08CEkQSRBYoTFCwIkM2GgEXwBxzCDYaARdzCEsDTwISRBJEFihMULAiQzYaARfAHHMJNhoBF3MJSwNPAhJEEkQWKExQsCJDNhoBF8Accwo2GgEXcwpLA08CEkQSRBYoTFCwIkM2GgEXwBxzCzYaARdzC0sDTwISRBJEFihMULAiQzYaARfAHHMMNhoBF3MMSwNPAhJEEkSAAQCBAE8CVChMULAiQzYaARfAHHMONhoBF3MOSwNPAhJEEkQWKExQsCJDNhoBF8Accw02GgEXcw1LA08CEkQSRBYoTFCwIkM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAcctParamsGetContract contract + */ +export type StateAcctParamsGetContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_acct_balance(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_min_balance(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_auth_addr(account)address': { + a: Uint8Array | string + } + 'verify_acct_total_num_uint(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_num_byte_slice(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_extra_app_pages(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_apps_created(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_apps_opted_in(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_assets_created(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_assets(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_boxes(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_total_box_bytes(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_incentive_eligible(account)bool': { + a: Uint8Array | string + } + 'verify_acct_last_heartbeat(account)uint64': { + a: Uint8Array | string + } + 'verify_acct_last_proposed(account)uint64': { + a: Uint8Array | string + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_acct_balance(account)uint64': [a: Uint8Array | string] + 'verify_acct_min_balance(account)uint64': [a: Uint8Array | string] + 'verify_acct_auth_addr(account)address': [a: Uint8Array | string] + 'verify_acct_total_num_uint(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_num_byte_slice(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_extra_app_pages(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_apps_created(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_apps_opted_in(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_assets_created(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_assets(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_boxes(account)uint64': [a: Uint8Array | string] + 'verify_acct_total_box_bytes(account)uint64': [a: Uint8Array | string] + 'verify_acct_incentive_eligible(account)bool': [a: Uint8Array | string] + 'verify_acct_last_heartbeat(account)uint64': [a: Uint8Array | string] + 'verify_acct_last_proposed(account)uint64': [a: Uint8Array | string] + } +} + +/** + * The return type for each method + */ +export type StateAcctParamsGetContractReturns = { + 'verify_acct_balance(account)uint64': bigint + 'verify_acct_min_balance(account)uint64': bigint + 'verify_acct_auth_addr(account)address': string + 'verify_acct_total_num_uint(account)uint64': bigint + 'verify_acct_total_num_byte_slice(account)uint64': bigint + 'verify_acct_total_extra_app_pages(account)uint64': bigint + 'verify_acct_total_apps_created(account)uint64': bigint + 'verify_acct_total_apps_opted_in(account)uint64': bigint + 'verify_acct_total_assets_created(account)uint64': bigint + 'verify_acct_total_assets(account)uint64': bigint + 'verify_acct_total_boxes(account)uint64': bigint + 'verify_acct_total_box_bytes(account)uint64': bigint + 'verify_acct_incentive_eligible(account)bool': boolean + 'verify_acct_last_heartbeat(account)uint64': bigint + 'verify_acct_last_proposed(account)uint64': bigint +} + +/** + * Defines the types of available calls and state of the StateAcctParamsGetContract smart contract. + */ +export type StateAcctParamsGetContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_acct_balance(account)uint64' | 'verify_acct_balance', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_balance(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_balance(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_balance(account)uint64'] + }> + & Record<'verify_acct_min_balance(account)uint64' | 'verify_acct_min_balance', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_min_balance(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_min_balance(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_min_balance(account)uint64'] + }> + & Record<'verify_acct_auth_addr(account)address' | 'verify_acct_auth_addr', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_auth_addr(account)address'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_auth_addr(account)address'] + returns: StateAcctParamsGetContractReturns['verify_acct_auth_addr(account)address'] + }> + & Record<'verify_acct_total_num_uint(account)uint64' | 'verify_acct_total_num_uint', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_num_uint(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_num_uint(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_num_uint(account)uint64'] + }> + & Record<'verify_acct_total_num_byte_slice(account)uint64' | 'verify_acct_total_num_byte_slice', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_num_byte_slice(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_num_byte_slice(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_num_byte_slice(account)uint64'] + }> + & Record<'verify_acct_total_extra_app_pages(account)uint64' | 'verify_acct_total_extra_app_pages', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_extra_app_pages(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_extra_app_pages(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_extra_app_pages(account)uint64'] + }> + & Record<'verify_acct_total_apps_created(account)uint64' | 'verify_acct_total_apps_created', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_apps_created(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_apps_created(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_apps_created(account)uint64'] + }> + & Record<'verify_acct_total_apps_opted_in(account)uint64' | 'verify_acct_total_apps_opted_in', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_apps_opted_in(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_apps_opted_in(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_apps_opted_in(account)uint64'] + }> + & Record<'verify_acct_total_assets_created(account)uint64' | 'verify_acct_total_assets_created', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_assets_created(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_assets_created(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_assets_created(account)uint64'] + }> + & Record<'verify_acct_total_assets(account)uint64' | 'verify_acct_total_assets', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_assets(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_assets(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_assets(account)uint64'] + }> + & Record<'verify_acct_total_boxes(account)uint64' | 'verify_acct_total_boxes', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_boxes(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_boxes(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_boxes(account)uint64'] + }> + & Record<'verify_acct_total_box_bytes(account)uint64' | 'verify_acct_total_box_bytes', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_total_box_bytes(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_total_box_bytes(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_total_box_bytes(account)uint64'] + }> + & Record<'verify_acct_incentive_eligible(account)bool' | 'verify_acct_incentive_eligible', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_incentive_eligible(account)bool'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_incentive_eligible(account)bool'] + returns: StateAcctParamsGetContractReturns['verify_acct_incentive_eligible(account)bool'] + }> + & Record<'verify_acct_last_heartbeat(account)uint64' | 'verify_acct_last_heartbeat', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_last_heartbeat(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_last_heartbeat(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_last_heartbeat(account)uint64'] + }> + & Record<'verify_acct_last_proposed(account)uint64' | 'verify_acct_last_proposed', { + argsObj: StateAcctParamsGetContractArgs['obj']['verify_acct_last_proposed(account)uint64'] + argsTuple: StateAcctParamsGetContractArgs['tuple']['verify_acct_last_proposed(account)uint64'] + returns: StateAcctParamsGetContractReturns['verify_acct_last_proposed(account)uint64'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAcctParamsGetContractSignatures = keyof StateAcctParamsGetContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StateAcctParamsGetContractNonVoidMethodSignatures = keyof StateAcctParamsGetContractTypes['methods'] extends infer T ? T extends keyof StateAcctParamsGetContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAcctParamsGetContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAcctParamsGetContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAcctParamsGetContract smart contract to the method's return type + */ +export type MethodReturn = StateAcctParamsGetContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAcctParamsGetContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAcctParamsGetContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAcctParamsGetContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAcctParamsGetContract smart contract + */ +export abstract class StateAcctParamsGetContractParamsFactory { + /** + * Constructs a no op call for the verify_acct_balance(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctBalance(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_balance(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_min_balance(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctMinBalance(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_min_balance(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_auth_addr(account)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctAuthAddr(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_auth_addr(account)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_num_uint(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalNumUint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_num_uint(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_num_byte_slice(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalNumByteSlice(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_num_byte_slice(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_extra_app_pages(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalExtraAppPages(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_extra_app_pages(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_apps_created(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalAppsCreated(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_apps_created(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_apps_opted_in(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalAppsOptedIn(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_apps_opted_in(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_assets_created(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalAssetsCreated(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_assets_created(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_assets(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalAssets(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_assets(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_boxes(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalBoxes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_boxes(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_total_box_bytes(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctTotalBoxBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_total_box_bytes(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_incentive_eligible(account)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctIncentiveEligible(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_incentive_eligible(account)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_last_heartbeat(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctLastHeartbeat(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_last_heartbeat(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_acct_last_proposed(account)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAcctLastProposed(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_acct_last_proposed(account)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StateAcctParamsGetContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAcctParamsGetContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAcctParamsGetContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAcctParamsGetContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAcctParamsGetContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAcctParamsGetContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAcctParamsGetContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAcctParamsGetContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAcctParamsGetContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAcctParamsGetContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAcctParamsGetContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAcctParamsGetContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAcctParamsGetContract smart contract + */ +export class StateAcctParamsGetContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAcctParamsGetContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAcctParamsGetContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAcctParamsGetContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAcctParamsGetContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAcctParamsGetContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAcctParamsGetContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAcctParamsGetContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the StateAcctParamsGetContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctBalance: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctBalance(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_min_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctMinBalance: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctMinBalance(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_auth_addr(account)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctAuthAddr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctAuthAddr(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_num_uint(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalNumUint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalNumUint(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_num_byte_slice(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalNumByteSlice: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalNumByteSlice(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_extra_app_pages(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalExtraAppPages: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalExtraAppPages(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_apps_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalAppsCreated: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAppsCreated(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_apps_opted_in(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalAppsOptedIn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAppsOptedIn(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_assets_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalAssetsCreated: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAssetsCreated(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_assets(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalAssets: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAssets(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_boxes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalBoxes(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_box_bytes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctTotalBoxBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalBoxBytes(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_incentive_eligible(account)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctIncentiveEligible: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctIncentiveEligible(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_last_heartbeat(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctLastHeartbeat: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctLastHeartbeat(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_last_proposed(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAcctLastProposed: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAcctParamsGetContractParamsFactory.verifyAcctLastProposed(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the StateAcctParamsGetContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctBalance: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctBalance(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_min_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctMinBalance: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctMinBalance(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_auth_addr(account)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctAuthAddr: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctAuthAddr(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_num_uint(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalNumUint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalNumUint(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_num_byte_slice(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalNumByteSlice: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalNumByteSlice(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_extra_app_pages(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalExtraAppPages: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalExtraAppPages(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_apps_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalAppsCreated: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAppsCreated(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_apps_opted_in(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalAppsOptedIn: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAppsOptedIn(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_assets_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalAssetsCreated: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAssetsCreated(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_assets(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalAssets: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAssets(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_boxes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalBoxes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalBoxes(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_box_bytes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctTotalBoxBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalBoxBytes(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_incentive_eligible(account)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctIncentiveEligible: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctIncentiveEligible(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_last_heartbeat(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctLastHeartbeat: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctLastHeartbeat(params)) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_last_proposed(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAcctLastProposed: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAcctParamsGetContractParamsFactory.verifyAcctLastProposed(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the StateAcctParamsGetContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctBalance: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctBalance(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_balance(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_min_balance(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctMinBalance: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctMinBalance(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_min_balance(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_auth_addr(account)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctAuthAddr: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctAuthAddr(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_auth_addr(account)address'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_num_uint(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalNumUint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalNumUint(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_num_uint(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_num_byte_slice(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalNumByteSlice: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalNumByteSlice(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_num_byte_slice(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_extra_app_pages(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalExtraAppPages: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalExtraAppPages(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_extra_app_pages(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_apps_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalAppsCreated: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAppsCreated(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_apps_created(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_apps_opted_in(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalAppsOptedIn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAppsOptedIn(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_apps_opted_in(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_assets_created(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalAssetsCreated: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAssetsCreated(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_assets_created(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_assets(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalAssets: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalAssets(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_assets(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_boxes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalBoxes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalBoxes(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_boxes(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_total_box_bytes(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctTotalBoxBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctTotalBoxBytes(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_total_box_bytes(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_incentive_eligible(account)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctIncentiveEligible: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctIncentiveEligible(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_incentive_eligible(account)bool'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_last_heartbeat(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctLastHeartbeat: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctLastHeartbeat(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_last_heartbeat(account)uint64'])} + }, + + /** + * Makes a call to the StateAcctParamsGetContract smart contract using the `verify_acct_last_proposed(account)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAcctLastProposed: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAcctParamsGetContractParamsFactory.verifyAcctLastProposed(params)) + return {...result, return: result.return as unknown as (undefined | StateAcctParamsGetContractReturns['verify_acct_last_proposed(account)uint64'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAcctParamsGetContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAcctParamsGetContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAcctParamsGetContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_acct_balance(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctBalance(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctBalance(params))) + return this + }, + /** + * Add a verify_acct_min_balance(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctMinBalance(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctMinBalance(params))) + return this + }, + /** + * Add a verify_acct_auth_addr(account)address method call against the StateAcctParamsGetContract contract + */ + verifyAcctAuthAddr(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctAuthAddr(params))) + return this + }, + /** + * Add a verify_acct_total_num_uint(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalNumUint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalNumUint(params))) + return this + }, + /** + * Add a verify_acct_total_num_byte_slice(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalNumByteSlice(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalNumByteSlice(params))) + return this + }, + /** + * Add a verify_acct_total_extra_app_pages(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalExtraAppPages(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalExtraAppPages(params))) + return this + }, + /** + * Add a verify_acct_total_apps_created(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalAppsCreated(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalAppsCreated(params))) + return this + }, + /** + * Add a verify_acct_total_apps_opted_in(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalAppsOptedIn(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalAppsOptedIn(params))) + return this + }, + /** + * Add a verify_acct_total_assets_created(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalAssetsCreated(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalAssetsCreated(params))) + return this + }, + /** + * Add a verify_acct_total_assets(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalAssets(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalAssets(params))) + return this + }, + /** + * Add a verify_acct_total_boxes(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalBoxes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalBoxes(params))) + return this + }, + /** + * Add a verify_acct_total_box_bytes(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctTotalBoxBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctTotalBoxBytes(params))) + return this + }, + /** + * Add a verify_acct_incentive_eligible(account)bool method call against the StateAcctParamsGetContract contract + */ + verifyAcctIncentiveEligible(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctIncentiveEligible(params))) + return this + }, + /** + * Add a verify_acct_last_heartbeat(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctLastHeartbeat(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctLastHeartbeat(params))) + return this + }, + /** + * Add a verify_acct_last_proposed(account)uint64 method call against the StateAcctParamsGetContract contract + */ + verifyAcctLastProposed(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAcctLastProposed(params))) + return this + }, + /** + * Add a clear state call to the StateAcctParamsGetContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAcctParamsGetContractComposer + } +} +export type StateAcctParamsGetContractComposer = { + /** + * Calls the verify_acct_balance(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctBalance(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_balance(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_min_balance(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctMinBalance(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_min_balance(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_auth_addr(account)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctAuthAddr(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_auth_addr(account)address'] | undefined]> + + /** + * Calls the verify_acct_total_num_uint(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalNumUint(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_num_uint(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_num_byte_slice(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalNumByteSlice(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_num_byte_slice(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_extra_app_pages(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalExtraAppPages(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_extra_app_pages(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_apps_created(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalAppsCreated(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_apps_created(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_apps_opted_in(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalAppsOptedIn(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_apps_opted_in(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_assets_created(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalAssetsCreated(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_assets_created(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_assets(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalAssets(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_assets(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_boxes(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalBoxes(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_boxes(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_total_box_bytes(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctTotalBoxBytes(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_total_box_bytes(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_incentive_eligible(account)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctIncentiveEligible(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_incentive_eligible(account)bool'] | undefined]> + + /** + * Calls the verify_acct_last_heartbeat(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctLastHeartbeat(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_last_heartbeat(account)uint64'] | undefined]> + + /** + * Calls the verify_acct_last_proposed(account)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAcctLastProposed(params?: CallParams): StateAcctParamsGetContractComposer<[...TReturns, StateAcctParamsGetContractReturns['verify_acct_last_proposed(account)uint64'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the StateAcctParamsGetContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAcctParamsGetContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAcctParamsGetContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAcctParamsGetContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAppGlobalContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppGlobalContract.ts new file mode 100644 index 0000000..fc6b74f --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppGlobalContract.ts @@ -0,0 +1,1018 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateAppGlobalContract","structs":{},"methods":[{"name":"verify_get_bytes","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_get_uint64","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_get_ex_bytes","args":[{"type":"uint64","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"(byte[],bool)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_get_ex_uint64","args":[{"type":"uint64","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"(uint64,bool)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_delete","args":[{"type":"byte[]","name":"a"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_put_uint64","args":[{"type":"byte[]","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_put_bytes","args":[{"type":"byte[]","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":1,"bytes":1},"local":{"ints":0,"bytes":0}},"keys":{"global":{"global_uint64":{"keyType":"AVMString","valueType":"AVMUint64","key":"Z2xvYmFsX3VpbnQ2NA=="},"global_bytes":{"keyType":"AVMString","valueType":"AVMBytes","key":"Z2xvYmFsX2J5dGVz"}},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIGludGNibG9jayAxIDAKICAgIGJ5dGVjYmxvY2sgMHgxNTFmN2M3NSAweDAwCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDQ1CiAgICAvLyBjbGFzcyBTdGF0ZUFwcEdsb2JhbENvbnRyYWN0KEFSQzRDb250cmFjdCk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9fX2FsZ29weV9kZWZhdWx0X2NyZWF0ZUAxNgogICAgdHhuIE9uQ29tcGxldGlvbgogICAgIQogICAgYXNzZXJ0CiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgYXNzZXJ0CiAgICBwdXNoYnl0ZXNzIDB4YTk5N2ExODcgMHg0ZGI4YWE0MSAweDBjMWY1NmE3IDB4YWZkZGIwODggMHg5M2E4NTJlMSAweDM2OTk2NDUxIDB4MzkyMGE1N2IgLy8gbWV0aG9kICJ2ZXJpZnlfZ2V0X2J5dGVzKGJ5dGVbXSlieXRlW10iLCBtZXRob2QgInZlcmlmeV9nZXRfdWludDY0KGJ5dGVbXSl1aW50NjQiLCBtZXRob2QgInZlcmlmeV9nZXRfZXhfYnl0ZXModWludDY0LGJ5dGVbXSkoYnl0ZVtdLGJvb2wpIiwgbWV0aG9kICJ2ZXJpZnlfZ2V0X2V4X3VpbnQ2NCh1aW50NjQsYnl0ZVtdKSh1aW50NjQsYm9vbCkiLCBtZXRob2QgInZlcmlmeV9kZWxldGUoYnl0ZVtdKXZvaWQiLCBtZXRob2QgInZlcmlmeV9wdXRfdWludDY0KGJ5dGVbXSx1aW50NjQpdm9pZCIsIG1ldGhvZCAidmVyaWZ5X3B1dF9ieXRlcyhieXRlW10sYnl0ZVtdKXZvaWQiCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCB2ZXJpZnlfZ2V0X2J5dGVzIHZlcmlmeV9nZXRfdWludDY0IHZlcmlmeV9nZXRfZXhfYnl0ZXMgdmVyaWZ5X2dldF9leF91aW50NjQgdmVyaWZ5X2RlbGV0ZSB2ZXJpZnlfcHV0X3VpbnQ2NCB2ZXJpZnlfcHV0X2J5dGVzCiAgICBlcnIKCm1haW5fX19hbGdvcHlfZGVmYXVsdF9jcmVhdGVAMTY6CiAgICB0eG4gT25Db21wbGV0aW9uCiAgICAhCiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgIQogICAgJiYKICAgIHJldHVybgoKCi8vIHRlc3RzLmFydGlmYWN0cy5TdGF0ZU9wcy5jb250cmFjdC5TdGF0ZUFwcEdsb2JhbENvbnRyYWN0LnZlcmlmeV9nZXRfYnl0ZXNbcm91dGluZ10oKSAtPiB2b2lkOgp2ZXJpZnlfZ2V0X2J5dGVzOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ1NwogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDEKICAgIGV4dHJhY3QgMiAwCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDU5CiAgICAvLyB2YWx1ZSA9IG9wLkFwcEdsb2JhbC5nZXRfYnl0ZXMoYSkKICAgIGFwcF9nbG9iYWxfZ2V0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDU3CiAgICAvLyBAYXJjNC5hYmltZXRob2QoKQogICAgZHVwCiAgICBsZW4KICAgIGl0b2IKICAgIGV4dHJhY3QgNiAyCiAgICBzd2FwCiAgICBjb25jYXQKICAgIGJ5dGVjXzAgLy8gMHgxNTFmN2M3NQogICAgc3dhcAogICAgY29uY2F0CiAgICBsb2cKICAgIGludGNfMCAvLyAxCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBHbG9iYWxDb250cmFjdC52ZXJpZnlfZ2V0X3VpbnQ2NFtyb3V0aW5nXSgpIC0+IHZvaWQ6CnZlcmlmeV9nZXRfdWludDY0OgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ2MgogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDEKICAgIGV4dHJhY3QgMiAwCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDY0CiAgICAvLyB2YWx1ZSA9IG9wLkFwcEdsb2JhbC5nZXRfdWludDY0KGEpCiAgICBhcHBfZ2xvYmFsX2dldAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ2MgogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIGl0b2IKICAgIGJ5dGVjXzAgLy8gMHgxNTFmN2M3NQogICAgc3dhcAogICAgY29uY2F0CiAgICBsb2cKICAgIGludGNfMCAvLyAxCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBHbG9iYWxDb250cmFjdC52ZXJpZnlfZ2V0X2V4X2J5dGVzW3JvdXRpbmddKCkgLT4gdm9pZDoKdmVyaWZ5X2dldF9leF9ieXRlczoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0NjcKICAgIC8vIEBhcmM0LmFiaW1ldGhvZCgpCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAxCiAgICBidG9pCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAyCiAgICBleHRyYWN0IDIgMAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ2OQogICAgLy8gcmV0dXJuIG9wLkFwcEdsb2JhbC5nZXRfZXhfYnl0ZXMoYSwgYikKICAgIGFwcF9nbG9iYWxfZ2V0X2V4CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDY3CiAgICAvLyBAYXJjNC5hYmltZXRob2QoKQogICAgZGlnIDEKICAgIGxlbgogICAgaXRvYgogICAgZXh0cmFjdCA2IDIKICAgIHVuY292ZXIgMgogICAgY29uY2F0CiAgICBieXRlY18xIC8vIDB4MDAKICAgIGludGNfMSAvLyAwCiAgICB1bmNvdmVyIDMKICAgIHNldGJpdAogICAgcHVzaGJ5dGVzIDB4MDAwMwogICAgc3dhcAogICAgY29uY2F0CiAgICBzd2FwCiAgICBjb25jYXQKICAgIGJ5dGVjXzAgLy8gMHgxNTFmN2M3NQogICAgc3dhcAogICAgY29uY2F0CiAgICBsb2cKICAgIGludGNfMCAvLyAxCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBHbG9iYWxDb250cmFjdC52ZXJpZnlfZ2V0X2V4X3VpbnQ2NFtyb3V0aW5nXSgpIC0+IHZvaWQ6CnZlcmlmeV9nZXRfZXhfdWludDY0OgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ3MQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDEKICAgIGJ0b2kKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDIKICAgIGV4dHJhY3QgMiAwCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDczCiAgICAvLyByZXR1cm4gb3AuQXBwR2xvYmFsLmdldF9leF91aW50NjQoYSwgYikKICAgIGFwcF9nbG9iYWxfZ2V0X2V4CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDcxCiAgICAvLyBAYXJjNC5hYmltZXRob2QoKQogICAgc3dhcAogICAgaXRvYgogICAgYnl0ZWNfMSAvLyAweDAwCiAgICBpbnRjXzEgLy8gMAogICAgdW5jb3ZlciAzCiAgICBzZXRiaXQKICAgIGNvbmNhdAogICAgYnl0ZWNfMCAvLyAweDE1MWY3Yzc1CiAgICBzd2FwCiAgICBjb25jYXQKICAgIGxvZwogICAgaW50Y18wIC8vIDEKICAgIHJldHVybgoKCi8vIHRlc3RzLmFydGlmYWN0cy5TdGF0ZU9wcy5jb250cmFjdC5TdGF0ZUFwcEdsb2JhbENvbnRyYWN0LnZlcmlmeV9kZWxldGVbcm91dGluZ10oKSAtPiB2b2lkOgp2ZXJpZnlfZGVsZXRlOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ3NQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDEKICAgIGV4dHJhY3QgMiAwCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDc3CiAgICAvLyBvcC5BcHBHbG9iYWwuZGVsZXRlKGEpCiAgICBhcHBfZ2xvYmFsX2RlbAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ3NQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIGludGNfMCAvLyAxCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBHbG9iYWxDb250cmFjdC52ZXJpZnlfcHV0X3VpbnQ2NFtyb3V0aW5nXSgpIC0+IHZvaWQ6CnZlcmlmeV9wdXRfdWludDY0OgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ3OQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDEKICAgIGV4dHJhY3QgMiAwCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAyCiAgICBidG9pCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDgxCiAgICAvLyBvcC5BcHBHbG9iYWwucHV0KGEsIGIpCiAgICBhcHBfZ2xvYmFsX3B1dAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ3OQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIGludGNfMCAvLyAxCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBHbG9iYWxDb250cmFjdC52ZXJpZnlfcHV0X2J5dGVzW3JvdXRpbmddKCkgLT4gdm9pZDoKdmVyaWZ5X3B1dF9ieXRlczoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0ODMKICAgIC8vIEBhcmM0LmFiaW1ldGhvZCgpCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAxCiAgICBleHRyYWN0IDIgMAogICAgdHhuYSBBcHBsaWNhdGlvbkFyZ3MgMgogICAgZXh0cmFjdCAyIDAKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0ODUKICAgIC8vIG9wLkFwcEdsb2JhbC5wdXQoYSwgYikKICAgIGFwcF9nbG9iYWxfcHV0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDgzCiAgICAvLyBAYXJjNC5hYmltZXRob2QoKQogICAgaW50Y18wIC8vIDEKICAgIHJldHVybgo=","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyACAQAmAgQVH3x1AQAxG0EAQDEZFEQxGESCBwSpl6GHBE24qkEEDB9WpwSv3bCIBJOoUuEENplkUQQ5IKV7NhoAjgcACQAeACwAVABtAHYAgwAxGRQxGBQQQzYaAVcCAGRJFRZXBgJMUChMULAiQzYaAVcCAGQWKExQsCJDNhoBFzYaAlcCAGVLARUWVwYCTwJQKSNPA1SAAgADTFBMUChMULAiQzYaARc2GgJXAgBlTBYpI08DVFAoTFCwIkM2GgFXAgBpIkM2GgFXAgA2GgIXZyJDNhoBVwIANhoCVwIAZyJD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAppGlobalContract contract + */ +export type StateAppGlobalContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_get_bytes(byte[])byte[]': { + a: Uint8Array + } + 'verify_get_uint64(byte[])uint64': { + a: Uint8Array + } + 'verify_get_ex_bytes(uint64,byte[])(byte[],bool)': { + a: bigint | number + b: Uint8Array + } + 'verify_get_ex_uint64(uint64,byte[])(uint64,bool)': { + a: bigint | number + b: Uint8Array + } + 'verify_delete(byte[])void': { + a: Uint8Array + } + 'verify_put_uint64(byte[],uint64)void': { + a: Uint8Array + b: bigint | number + } + 'verify_put_bytes(byte[],byte[])void': { + a: Uint8Array + b: Uint8Array + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_get_bytes(byte[])byte[]': [a: Uint8Array] + 'verify_get_uint64(byte[])uint64': [a: Uint8Array] + 'verify_get_ex_bytes(uint64,byte[])(byte[],bool)': [a: bigint | number, b: Uint8Array] + 'verify_get_ex_uint64(uint64,byte[])(uint64,bool)': [a: bigint | number, b: Uint8Array] + 'verify_delete(byte[])void': [a: Uint8Array] + 'verify_put_uint64(byte[],uint64)void': [a: Uint8Array, b: bigint | number] + 'verify_put_bytes(byte[],byte[])void': [a: Uint8Array, b: Uint8Array] + } +} + +/** + * The return type for each method + */ +export type StateAppGlobalContractReturns = { + 'verify_get_bytes(byte[])byte[]': Uint8Array + 'verify_get_uint64(byte[])uint64': bigint + 'verify_get_ex_bytes(uint64,byte[])(byte[],bool)': [Uint8Array, boolean] + 'verify_get_ex_uint64(uint64,byte[])(uint64,bool)': [bigint, boolean] + 'verify_delete(byte[])void': void + 'verify_put_uint64(byte[],uint64)void': void + 'verify_put_bytes(byte[],byte[])void': void +} + +/** + * Defines the types of available calls and state of the StateAppGlobalContract smart contract. + */ +export type StateAppGlobalContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_get_bytes(byte[])byte[]' | 'verify_get_bytes', { + argsObj: StateAppGlobalContractArgs['obj']['verify_get_bytes(byte[])byte[]'] + argsTuple: StateAppGlobalContractArgs['tuple']['verify_get_bytes(byte[])byte[]'] + returns: StateAppGlobalContractReturns['verify_get_bytes(byte[])byte[]'] + }> + & Record<'verify_get_uint64(byte[])uint64' | 'verify_get_uint64', { + argsObj: StateAppGlobalContractArgs['obj']['verify_get_uint64(byte[])uint64'] + argsTuple: StateAppGlobalContractArgs['tuple']['verify_get_uint64(byte[])uint64'] + returns: StateAppGlobalContractReturns['verify_get_uint64(byte[])uint64'] + }> + & Record<'verify_get_ex_bytes(uint64,byte[])(byte[],bool)' | 'verify_get_ex_bytes', { + argsObj: StateAppGlobalContractArgs['obj']['verify_get_ex_bytes(uint64,byte[])(byte[],bool)'] + argsTuple: StateAppGlobalContractArgs['tuple']['verify_get_ex_bytes(uint64,byte[])(byte[],bool)'] + returns: StateAppGlobalContractReturns['verify_get_ex_bytes(uint64,byte[])(byte[],bool)'] + }> + & Record<'verify_get_ex_uint64(uint64,byte[])(uint64,bool)' | 'verify_get_ex_uint64', { + argsObj: StateAppGlobalContractArgs['obj']['verify_get_ex_uint64(uint64,byte[])(uint64,bool)'] + argsTuple: StateAppGlobalContractArgs['tuple']['verify_get_ex_uint64(uint64,byte[])(uint64,bool)'] + returns: StateAppGlobalContractReturns['verify_get_ex_uint64(uint64,byte[])(uint64,bool)'] + }> + & Record<'verify_delete(byte[])void' | 'verify_delete', { + argsObj: StateAppGlobalContractArgs['obj']['verify_delete(byte[])void'] + argsTuple: StateAppGlobalContractArgs['tuple']['verify_delete(byte[])void'] + returns: StateAppGlobalContractReturns['verify_delete(byte[])void'] + }> + & Record<'verify_put_uint64(byte[],uint64)void' | 'verify_put_uint64', { + argsObj: StateAppGlobalContractArgs['obj']['verify_put_uint64(byte[],uint64)void'] + argsTuple: StateAppGlobalContractArgs['tuple']['verify_put_uint64(byte[],uint64)void'] + returns: StateAppGlobalContractReturns['verify_put_uint64(byte[],uint64)void'] + }> + & Record<'verify_put_bytes(byte[],byte[])void' | 'verify_put_bytes', { + argsObj: StateAppGlobalContractArgs['obj']['verify_put_bytes(byte[],byte[])void'] + argsTuple: StateAppGlobalContractArgs['tuple']['verify_put_bytes(byte[],byte[])void'] + returns: StateAppGlobalContractReturns['verify_put_bytes(byte[],byte[])void'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + global: { + keys: { + globalUint64: bigint + globalBytes: BinaryState + } + maps: {} + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAppGlobalContractSignatures = keyof StateAppGlobalContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StateAppGlobalContractNonVoidMethodSignatures = keyof StateAppGlobalContractTypes['methods'] extends infer T ? T extends keyof StateAppGlobalContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAppGlobalContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAppGlobalContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAppGlobalContract smart contract to the method's return type + */ +export type MethodReturn = StateAppGlobalContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed global state of the application. + */ +export type GlobalKeysState = StateAppGlobalContractTypes['state']['global']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAppGlobalContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAppGlobalContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAppGlobalContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAppGlobalContract smart contract + */ +export abstract class StateAppGlobalContractParamsFactory { + /** + * Constructs a no op call for the verify_get_bytes(byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_get_bytes(byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_get_uint64(byte[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_get_uint64(byte[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_get_ex_bytes(uint64,byte[])(byte[],bool) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetExBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_get_ex_bytes(uint64,byte[])(byte[],bool)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_get_ex_uint64(uint64,byte[])(uint64,bool) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetExUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_get_ex_uint64(uint64,byte[])(uint64,bool)' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_delete(byte[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyDelete(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_delete(byte[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_put_uint64(byte[],uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyPutUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_put_uint64(byte[],uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_put_bytes(byte[],byte[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyPutBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_put_bytes(byte[],byte[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StateAppGlobalContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAppGlobalContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAppGlobalContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAppGlobalContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAppGlobalContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAppGlobalContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAppGlobalContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAppGlobalContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppGlobalContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppGlobalContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppGlobalContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAppGlobalContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAppGlobalContract smart contract + */ +export class StateAppGlobalContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAppGlobalContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAppGlobalContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAppGlobalContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAppGlobalContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAppGlobalContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAppGlobalContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAppGlobalContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the StateAppGlobalContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_bytes(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppGlobalContractParamsFactory.verifyGetBytes(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppGlobalContractParamsFactory.verifyGetUint64(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_ex_bytes(uint64,byte[])(byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetExBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppGlobalContractParamsFactory.verifyGetExBytes(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_ex_uint64(uint64,byte[])(uint64,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetExUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppGlobalContractParamsFactory.verifyGetExUint64(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_delete(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyDelete: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppGlobalContractParamsFactory.verifyDelete(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_put_uint64(byte[],uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyPutUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppGlobalContractParamsFactory.verifyPutUint64(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_put_bytes(byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyPutBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppGlobalContractParamsFactory.verifyPutBytes(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the StateAppGlobalContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_bytes(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppGlobalContractParamsFactory.verifyGetBytes(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppGlobalContractParamsFactory.verifyGetUint64(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_ex_bytes(uint64,byte[])(byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetExBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppGlobalContractParamsFactory.verifyGetExBytes(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_ex_uint64(uint64,byte[])(uint64,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetExUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppGlobalContractParamsFactory.verifyGetExUint64(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_delete(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyDelete: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppGlobalContractParamsFactory.verifyDelete(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_put_uint64(byte[],uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyPutUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppGlobalContractParamsFactory.verifyPutUint64(params)) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_put_bytes(byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyPutBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppGlobalContractParamsFactory.verifyPutBytes(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the StateAppGlobalContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_bytes(byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppGlobalContractParamsFactory.verifyGetBytes(params)) + return {...result, return: result.return as unknown as (undefined | StateAppGlobalContractReturns['verify_get_bytes(byte[])byte[]'])} + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_uint64(byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppGlobalContractParamsFactory.verifyGetUint64(params)) + return {...result, return: result.return as unknown as (undefined | StateAppGlobalContractReturns['verify_get_uint64(byte[])uint64'])} + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_ex_bytes(uint64,byte[])(byte[],bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetExBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppGlobalContractParamsFactory.verifyGetExBytes(params)) + return {...result, return: result.return as unknown as (undefined | StateAppGlobalContractReturns['verify_get_ex_bytes(uint64,byte[])(byte[],bool)'])} + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_get_ex_uint64(uint64,byte[])(uint64,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetExUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppGlobalContractParamsFactory.verifyGetExUint64(params)) + return {...result, return: result.return as unknown as (undefined | StateAppGlobalContractReturns['verify_get_ex_uint64(uint64,byte[])(uint64,bool)'])} + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_delete(byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyDelete: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppGlobalContractParamsFactory.verifyDelete(params)) + return {...result, return: result.return as unknown as (undefined | StateAppGlobalContractReturns['verify_delete(byte[])void'])} + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_put_uint64(byte[],uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyPutUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppGlobalContractParamsFactory.verifyPutUint64(params)) + return {...result, return: result.return as unknown as (undefined | StateAppGlobalContractReturns['verify_put_uint64(byte[],uint64)void'])} + }, + + /** + * Makes a call to the StateAppGlobalContract smart contract using the `verify_put_bytes(byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyPutBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppGlobalContractParamsFactory.verifyPutBytes(params)) + return {...result, return: result.return as unknown as (undefined | StateAppGlobalContractReturns['verify_put_bytes(byte[],byte[])void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAppGlobalContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAppGlobalContract app + */ + state = { + /** + * Methods to access global state for the current StateAppGlobalContract app + */ + global: { + /** + * Get all current keyed values from global state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.global.getAll() + return { + globalUint64: result.global_uint64, + globalBytes: new BinaryStateValue(result.global_bytes), + } + }, + /** + * Get the current value of the global_uint64 key in global state + */ + globalUint64: async (): Promise => { return (await this.appClient.state.global.getValue("global_uint64")) as bigint | undefined }, + /** + * Get the current value of the global_bytes key in global state + */ + globalBytes: async (): Promise => { return new BinaryStateValue((await this.appClient.state.global.getValue("global_bytes")) as Uint8Array | undefined) }, + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAppGlobalContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_get_bytes(byte[])byte[] method call against the StateAppGlobalContract contract + */ + verifyGetBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetBytes(params))) + return this + }, + /** + * Add a verify_get_uint64(byte[])uint64 method call against the StateAppGlobalContract contract + */ + verifyGetUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetUint64(params))) + return this + }, + /** + * Add a verify_get_ex_bytes(uint64,byte[])(byte[],bool) method call against the StateAppGlobalContract contract + */ + verifyGetExBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetExBytes(params))) + return this + }, + /** + * Add a verify_get_ex_uint64(uint64,byte[])(uint64,bool) method call against the StateAppGlobalContract contract + */ + verifyGetExUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetExUint64(params))) + return this + }, + /** + * Add a verify_delete(byte[])void method call against the StateAppGlobalContract contract + */ + verifyDelete(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyDelete(params))) + return this + }, + /** + * Add a verify_put_uint64(byte[],uint64)void method call against the StateAppGlobalContract contract + */ + verifyPutUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyPutUint64(params))) + return this + }, + /** + * Add a verify_put_bytes(byte[],byte[])void method call against the StateAppGlobalContract contract + */ + verifyPutBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyPutBytes(params))) + return this + }, + /** + * Add a clear state call to the StateAppGlobalContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAppGlobalContractComposer + } +} +export type StateAppGlobalContractComposer = { + /** + * Calls the verify_get_bytes(byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetBytes(params?: CallParams): StateAppGlobalContractComposer<[...TReturns, StateAppGlobalContractReturns['verify_get_bytes(byte[])byte[]'] | undefined]> + + /** + * Calls the verify_get_uint64(byte[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetUint64(params?: CallParams): StateAppGlobalContractComposer<[...TReturns, StateAppGlobalContractReturns['verify_get_uint64(byte[])uint64'] | undefined]> + + /** + * Calls the verify_get_ex_bytes(uint64,byte[])(byte[],bool) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetExBytes(params?: CallParams): StateAppGlobalContractComposer<[...TReturns, StateAppGlobalContractReturns['verify_get_ex_bytes(uint64,byte[])(byte[],bool)'] | undefined]> + + /** + * Calls the verify_get_ex_uint64(uint64,byte[])(uint64,bool) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetExUint64(params?: CallParams): StateAppGlobalContractComposer<[...TReturns, StateAppGlobalContractReturns['verify_get_ex_uint64(uint64,byte[])(uint64,bool)'] | undefined]> + + /** + * Calls the verify_delete(byte[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyDelete(params?: CallParams): StateAppGlobalContractComposer<[...TReturns, StateAppGlobalContractReturns['verify_delete(byte[])void'] | undefined]> + + /** + * Calls the verify_put_uint64(byte[],uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyPutUint64(params?: CallParams): StateAppGlobalContractComposer<[...TReturns, StateAppGlobalContractReturns['verify_put_uint64(byte[],uint64)void'] | undefined]> + + /** + * Calls the verify_put_bytes(byte[],byte[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyPutBytes(params?: CallParams): StateAppGlobalContractComposer<[...TReturns, StateAppGlobalContractReturns['verify_put_bytes(byte[],byte[])void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the StateAppGlobalContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAppGlobalContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAppGlobalContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAppGlobalContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAppGlobalExContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppGlobalExContract.ts new file mode 100644 index 0000000..cf78371 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppGlobalExContract.ts @@ -0,0 +1,551 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateAppGlobalExContract","structs":{},"methods":[],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":2,"bytes":4},"local":{"ints":0,"bytes":0}},"keys":{"global":{"global_uint64":{"keyType":"AVMString","valueType":"AVMUint64","key":"Z2xvYmFsX3VpbnQ2NA=="},"global_bytes":{"keyType":"AVMString","valueType":"AVMBytes","key":"Z2xvYmFsX2J5dGVz"},"global_uint64_explicit":{"keyType":"AVMString","valueType":"AVMUint64","key":"Z2xvYmFsX3VpbnQ2NF9leHBsaWNpdA=="},"global_bytes_explicit":{"keyType":"AVMString","valueType":"AVMBytes","key":"Z2xvYmFsX2J5dGVzX2V4cGxpY2l0"},"global_arc4_bytes":{"keyType":"AVMString","valueType":"byte[]","key":"Z2xvYmFsX2FyYzRfYnl0ZXM="},"global_arc4_bytes_explicit":{"keyType":"AVMString","valueType":"byte[]","key":"Z2xvYmFsX2FyYzRfYnl0ZXNfZXhwbGljaXQ="}},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyYCC2R1bW15X2J5dGVzEgAQZHVtbXlfYXJjNF9ieXRlczEYQACJgA1nbG9iYWxfdWludDY0gQJngAxnbG9iYWxfYnl0ZXMoZ4AWZ2xvYmFsX3VpbnQ2NF9leHBsaWNpdIECZ4AVZ2xvYmFsX2J5dGVzX2V4cGxpY2l0KGeAEWdsb2JhbF9hcmM0X2J5dGVzKWeAGmdsb2JhbF9hcmM0X2J5dGVzX2V4cGxpY2l0KWcxGxREMRkUMRgUEEM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAppGlobalExContract contract + */ +export type StateAppGlobalExContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + } +} + +/** + * The return type for each method + */ +export type StateAppGlobalExContractReturns = { +} + +/** + * Defines the types of available calls and state of the StateAppGlobalExContract smart contract. + */ +export type StateAppGlobalExContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: {} + /** + * Defines the shape of the state of the application. + */ + state: { + global: { + keys: { + globalUint64: bigint + globalBytes: BinaryState + globalUint64Explicit: bigint + globalBytesExplicit: BinaryState + globalArc4Bytes: Uint8Array + globalArc4BytesExplicit: Uint8Array + } + maps: {} + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAppGlobalExContractSignatures = keyof StateAppGlobalExContractTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAppGlobalExContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAppGlobalExContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAppGlobalExContract smart contract to the method's return type + */ +export type MethodReturn = StateAppGlobalExContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed global state of the application. + */ +export type GlobalKeysState = StateAppGlobalExContractTypes['state']['global']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAppGlobalExContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAppGlobalExContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAppGlobalExContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAppGlobalExContract smart contract + */ +export abstract class StateAppGlobalExContractParamsFactory { +} + +/** + * A factory to create and deploy one or more instance of the StateAppGlobalExContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAppGlobalExContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAppGlobalExContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAppGlobalExContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAppGlobalExContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAppGlobalExContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAppGlobalExContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAppGlobalExContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppGlobalExContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppGlobalExContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppGlobalExContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAppGlobalExContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAppGlobalExContract smart contract + */ +export class StateAppGlobalExContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAppGlobalExContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAppGlobalExContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAppGlobalExContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAppGlobalExContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAppGlobalExContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAppGlobalExContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAppGlobalExContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the StateAppGlobalExContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the StateAppGlobalExContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the StateAppGlobalExContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAppGlobalExContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAppGlobalExContract app + */ + state = { + /** + * Methods to access global state for the current StateAppGlobalExContract app + */ + global: { + /** + * Get all current keyed values from global state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.global.getAll() + return { + globalUint64: result.global_uint64, + globalBytes: new BinaryStateValue(result.global_bytes), + globalUint64Explicit: result.global_uint64_explicit, + globalBytesExplicit: new BinaryStateValue(result.global_bytes_explicit), + globalArc4Bytes: result.global_arc4_bytes, + globalArc4BytesExplicit: result.global_arc4_bytes_explicit, + } + }, + /** + * Get the current value of the global_uint64 key in global state + */ + globalUint64: async (): Promise => { return (await this.appClient.state.global.getValue("global_uint64")) as bigint | undefined }, + /** + * Get the current value of the global_bytes key in global state + */ + globalBytes: async (): Promise => { return new BinaryStateValue((await this.appClient.state.global.getValue("global_bytes")) as Uint8Array | undefined) }, + /** + * Get the current value of the global_uint64_explicit key in global state + */ + globalUint64Explicit: async (): Promise => { return (await this.appClient.state.global.getValue("global_uint64_explicit")) as bigint | undefined }, + /** + * Get the current value of the global_bytes_explicit key in global state + */ + globalBytesExplicit: async (): Promise => { return new BinaryStateValue((await this.appClient.state.global.getValue("global_bytes_explicit")) as Uint8Array | undefined) }, + /** + * Get the current value of the global_arc4_bytes key in global state + */ + globalArc4Bytes: async (): Promise => { return (await this.appClient.state.global.getValue("global_arc4_bytes")) as Uint8Array | undefined }, + /** + * Get the current value of the global_arc4_bytes_explicit key in global state + */ + globalArc4BytesExplicit: async (): Promise => { return (await this.appClient.state.global.getValue("global_arc4_bytes_explicit")) as Uint8Array | undefined }, + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAppGlobalExContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a clear state call to the StateAppGlobalExContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAppGlobalExContractComposer + } +} +export type StateAppGlobalExContractComposer = { + /** + * Makes a clear_state call to an existing instance of the StateAppGlobalExContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAppGlobalExContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAppGlobalExContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAppGlobalExContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAppLocalContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppLocalContract.ts new file mode 100644 index 0000000..be9dae8 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppLocalContract.ts @@ -0,0 +1,1197 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateAppLocalContract","structs":{},"methods":[{"name":"opt_in","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["OptIn"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_get_bytes","args":[{"type":"address","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_get_uint64","args":[{"type":"address","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_get_ex_bytes","args":[{"type":"address","name":"a"},{"type":"uint64","name":"b"},{"type":"byte[]","name":"c"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_get_ex_uint64","args":[{"type":"address","name":"a"},{"type":"uint64","name":"b"},{"type":"byte[]","name":"c"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_delete","args":[{"type":"address","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_exists","args":[{"type":"address","name":"a"},{"type":"byte[]","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_put_uint64","args":[{"type":"address","name":"a"},{"type":"byte[]","name":"b"},{"type":"uint64","name":"c"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_put_bytes","args":[{"type":"address","name":"a"},{"type":"byte[]","name":"b"},{"type":"byte[]","name":"c"}],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":1,"bytes":1}},"keys":{"global":{},"local":{"local_uint64":{"keyType":"AVMString","valueType":"AVMUint64","key":"bG9jYWxfdWludDY0"},"local_bytes":{"keyType":"AVMString","valueType":"AVMBytes","key":"bG9jYWxfYnl0ZXM="}},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:372
    // class StateAppLocalContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@19
    pushbytes 0x30c6d58a // method "opt_in()void"
    txna ApplicationArgs 0
    match main_opt_in_route@5

main_switch_case_next@6:
    // tests/artifacts/StateOps/contract.py:372
    // class StateAppLocalContract(ARC4Contract):
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0xa88302fe 0x49b7ddf9 0xc078bead 0xa52f992b 0x8c56ad90 0x4c7ad823 0xcaa7b864 0x24f9f085 // method "verify_get_bytes(address,byte[])byte[]", method "verify_get_uint64(address,byte[])uint64", method "verify_get_ex_bytes(address,uint64,byte[])byte[]", method "verify_get_ex_uint64(address,uint64,byte[])uint64", method "verify_delete(address,byte[])void", method "verify_exists(address,byte[])bool", method "verify_put_uint64(address,byte[],uint64)void", method "verify_put_bytes(address,byte[],byte[])void"
    txna ApplicationArgs 0
    match verify_get_bytes verify_get_uint64 verify_get_ex_bytes verify_get_ex_uint64 verify_delete verify_exists verify_put_uint64 verify_put_bytes
    err

main_opt_in_route@5:
    // tests/artifacts/StateOps/contract.py:384
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    intc_0 // OptIn
    ==
    txn ApplicationID
    &&
    assert
    b opt_in

main___algopy_default_create@19:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.opt_in[routing]() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:386
    // self.local_bytes[Global.creator_address] = Bytes(b"dummy_bytes")
    global CreatorAddress
    pushbytess "local_bytes" 0x64756d6d795f6279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:387
    // self.local_uint64[Global.creator_address] = UInt64(999)
    global CreatorAddress
    pushbytes "local_uint64"
    pushint 999
    app_local_put
    // tests/artifacts/StateOps/contract.py:384
    // @arc4.abimethod(allow_actions=["OptIn"])
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_bytes[routing]() -> void:
verify_get_bytes:
    // tests/artifacts/StateOps/contract.py:389
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:391
    // value = op.AppLocal.get_bytes(a, b)
    app_local_get
    // tests/artifacts/StateOps/contract.py:389
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_uint64[routing]() -> void:
verify_get_uint64:
    // tests/artifacts/StateOps/contract.py:394
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:396
    // value = op.AppLocal.get_uint64(a, b)
    app_local_get
    // tests/artifacts/StateOps/contract.py:394
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_ex_bytes[routing]() -> void:
verify_get_ex_bytes:
    // tests/artifacts/StateOps/contract.py:399
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:401
    // value, _val = op.AppLocal.get_ex_bytes(a, b, c)
    app_local_get_ex
    pop
    // tests/artifacts/StateOps/contract.py:399
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_ex_uint64[routing]() -> void:
verify_get_ex_uint64:
    // tests/artifacts/StateOps/contract.py:404
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:406
    // value, _val = op.AppLocal.get_ex_uint64(a, b, c)
    app_local_get_ex
    pop
    // tests/artifacts/StateOps/contract.py:404
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_delete[routing]() -> void:
verify_delete:
    // tests/artifacts/StateOps/contract.py:409
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:411
    // op.AppLocal.delete(a, b)
    app_local_del
    // tests/artifacts/StateOps/contract.py:409
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_exists[routing]() -> void:
verify_exists:
    // tests/artifacts/StateOps/contract.py:413
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:415
    // _value, exists = op.AppLocal.get_ex_uint64(a, 0, b)
    intc_1 // 0
    swap
    app_local_get_ex
    bury 1
    // tests/artifacts/StateOps/contract.py:413
    // @arc4.abimethod()
    pushbytes 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_put_uint64[routing]() -> void:
verify_put_uint64:
    // tests/artifacts/StateOps/contract.py:418
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/StateOps/contract.py:420
    // op.AppLocal.put(a, b, c)
    app_local_put
    // tests/artifacts/StateOps/contract.py:418
    // @arc4.abimethod()
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_put_bytes[routing]() -> void:
verify_put_bytes:
    // tests/artifacts/StateOps/contract.py:422
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:424
    // op.AppLocal.put(a, b, c)
    app_local_put
    // tests/artifacts/StateOps/contract.py:422
    // @arc4.abimethod()
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyACAQAmAQQVH3x1MRtBAF+ABDDG1Yo2GgCOAQBHMRkURDEYRIIIBKiDAv4ESbfd+QTAeL6tBKUvmSsEjFatkARMetgjBMqnuGQEJPnwhTYaAI4IAEcAXwBwAI0AowCvAMoA2gAxGSISMRgQREIACDEZFDEYFBBDMgmCAgtsb2NhbF9ieXRlcwtkdW1teV9ieXRlc2YyCYAMbG9jYWxfdWludDY0gecHZiJDNhoBNhoCVwIAYkkVFlcGAkxQKExQsCJDNhoBNhoCVwIAYhYoTFCwIkM2GgE2GgIXNhoDVwIAY0hJFRZXBgJMUChMULAiQzYaATYaAhc2GgNXAgBjSBYoTFCwIkM2GgE2GgJXAgBoIkM2GgE2GgJXAgAjTGNFAYABACNPAlQoTFCwIkM2GgE2GgJXAgA2GgMXZiJDNhoBNhoCVwIANhoDVwIAZiJD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAppLocalContract contract + */ +export type StateAppLocalContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'opt_in()void': Record + 'verify_get_bytes(address,byte[])byte[]': { + a: string + b: Uint8Array + } + 'verify_get_uint64(address,byte[])uint64': { + a: string + b: Uint8Array + } + 'verify_get_ex_bytes(address,uint64,byte[])byte[]': { + a: string + b: bigint | number + c: Uint8Array + } + 'verify_get_ex_uint64(address,uint64,byte[])uint64': { + a: string + b: bigint | number + c: Uint8Array + } + 'verify_delete(address,byte[])void': { + a: string + b: Uint8Array + } + 'verify_exists(address,byte[])bool': { + a: string + b: Uint8Array + } + 'verify_put_uint64(address,byte[],uint64)void': { + a: string + b: Uint8Array + c: bigint | number + } + 'verify_put_bytes(address,byte[],byte[])void': { + a: string + b: Uint8Array + c: Uint8Array + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'opt_in()void': [] + 'verify_get_bytes(address,byte[])byte[]': [a: string, b: Uint8Array] + 'verify_get_uint64(address,byte[])uint64': [a: string, b: Uint8Array] + 'verify_get_ex_bytes(address,uint64,byte[])byte[]': [a: string, b: bigint | number, c: Uint8Array] + 'verify_get_ex_uint64(address,uint64,byte[])uint64': [a: string, b: bigint | number, c: Uint8Array] + 'verify_delete(address,byte[])void': [a: string, b: Uint8Array] + 'verify_exists(address,byte[])bool': [a: string, b: Uint8Array] + 'verify_put_uint64(address,byte[],uint64)void': [a: string, b: Uint8Array, c: bigint | number] + 'verify_put_bytes(address,byte[],byte[])void': [a: string, b: Uint8Array, c: Uint8Array] + } +} + +/** + * The return type for each method + */ +export type StateAppLocalContractReturns = { + 'opt_in()void': void + 'verify_get_bytes(address,byte[])byte[]': Uint8Array + 'verify_get_uint64(address,byte[])uint64': bigint + 'verify_get_ex_bytes(address,uint64,byte[])byte[]': Uint8Array + 'verify_get_ex_uint64(address,uint64,byte[])uint64': bigint + 'verify_delete(address,byte[])void': void + 'verify_exists(address,byte[])bool': boolean + 'verify_put_uint64(address,byte[],uint64)void': void + 'verify_put_bytes(address,byte[],byte[])void': void +} + +/** + * Defines the types of available calls and state of the StateAppLocalContract smart contract. + */ +export type StateAppLocalContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'opt_in()void' | 'opt_in', { + argsObj: StateAppLocalContractArgs['obj']['opt_in()void'] + argsTuple: StateAppLocalContractArgs['tuple']['opt_in()void'] + returns: StateAppLocalContractReturns['opt_in()void'] + }> + & Record<'verify_get_bytes(address,byte[])byte[]' | 'verify_get_bytes', { + argsObj: StateAppLocalContractArgs['obj']['verify_get_bytes(address,byte[])byte[]'] + argsTuple: StateAppLocalContractArgs['tuple']['verify_get_bytes(address,byte[])byte[]'] + returns: StateAppLocalContractReturns['verify_get_bytes(address,byte[])byte[]'] + }> + & Record<'verify_get_uint64(address,byte[])uint64' | 'verify_get_uint64', { + argsObj: StateAppLocalContractArgs['obj']['verify_get_uint64(address,byte[])uint64'] + argsTuple: StateAppLocalContractArgs['tuple']['verify_get_uint64(address,byte[])uint64'] + returns: StateAppLocalContractReturns['verify_get_uint64(address,byte[])uint64'] + }> + & Record<'verify_get_ex_bytes(address,uint64,byte[])byte[]' | 'verify_get_ex_bytes', { + argsObj: StateAppLocalContractArgs['obj']['verify_get_ex_bytes(address,uint64,byte[])byte[]'] + argsTuple: StateAppLocalContractArgs['tuple']['verify_get_ex_bytes(address,uint64,byte[])byte[]'] + returns: StateAppLocalContractReturns['verify_get_ex_bytes(address,uint64,byte[])byte[]'] + }> + & Record<'verify_get_ex_uint64(address,uint64,byte[])uint64' | 'verify_get_ex_uint64', { + argsObj: StateAppLocalContractArgs['obj']['verify_get_ex_uint64(address,uint64,byte[])uint64'] + argsTuple: StateAppLocalContractArgs['tuple']['verify_get_ex_uint64(address,uint64,byte[])uint64'] + returns: StateAppLocalContractReturns['verify_get_ex_uint64(address,uint64,byte[])uint64'] + }> + & Record<'verify_delete(address,byte[])void' | 'verify_delete', { + argsObj: StateAppLocalContractArgs['obj']['verify_delete(address,byte[])void'] + argsTuple: StateAppLocalContractArgs['tuple']['verify_delete(address,byte[])void'] + returns: StateAppLocalContractReturns['verify_delete(address,byte[])void'] + }> + & Record<'verify_exists(address,byte[])bool' | 'verify_exists', { + argsObj: StateAppLocalContractArgs['obj']['verify_exists(address,byte[])bool'] + argsTuple: StateAppLocalContractArgs['tuple']['verify_exists(address,byte[])bool'] + returns: StateAppLocalContractReturns['verify_exists(address,byte[])bool'] + }> + & Record<'verify_put_uint64(address,byte[],uint64)void' | 'verify_put_uint64', { + argsObj: StateAppLocalContractArgs['obj']['verify_put_uint64(address,byte[],uint64)void'] + argsTuple: StateAppLocalContractArgs['tuple']['verify_put_uint64(address,byte[],uint64)void'] + returns: StateAppLocalContractReturns['verify_put_uint64(address,byte[],uint64)void'] + }> + & Record<'verify_put_bytes(address,byte[],byte[])void' | 'verify_put_bytes', { + argsObj: StateAppLocalContractArgs['obj']['verify_put_bytes(address,byte[],byte[])void'] + argsTuple: StateAppLocalContractArgs['tuple']['verify_put_bytes(address,byte[],byte[])void'] + returns: StateAppLocalContractReturns['verify_put_bytes(address,byte[],byte[])void'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + local: { + keys: { + localUint64: bigint + localBytes: BinaryState + } + maps: {} + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAppLocalContractSignatures = keyof StateAppLocalContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StateAppLocalContractNonVoidMethodSignatures = keyof StateAppLocalContractTypes['methods'] extends infer T ? T extends keyof StateAppLocalContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAppLocalContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAppLocalContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAppLocalContract smart contract to the method's return type + */ +export type MethodReturn = StateAppLocalContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed local state of the application. + */ +export type LocalKeysState = StateAppLocalContractTypes['state']['local']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAppLocalContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAppLocalContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAppLocalContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAppLocalContract smart contract + */ +export abstract class StateAppLocalContractParamsFactory { + /** + * Gets available optIn ABI call param factories + */ + static get optIn() { + return { + /** + * Constructs opt-in ABI call params for the StateAppLocalContract smart contract using the opt_in()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + optIn(params: CallParams): AppClientMethodCallParams { + return { + ...params, + method: 'opt_in()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + }, + } + } + + /** + * Constructs a no op call for the verify_get_bytes(address,byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_get_bytes(address,byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_get_uint64(address,byte[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_get_uint64(address,byte[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_get_ex_bytes(address,uint64,byte[])byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetExBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_get_ex_bytes(address,uint64,byte[])byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_get_ex_uint64(address,uint64,byte[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyGetExUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_get_ex_uint64(address,uint64,byte[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_delete(address,byte[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyDelete(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_delete(address,byte[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_exists(address,byte[])bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyExists(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_exists(address,byte[])bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_put_uint64(address,byte[],uint64)void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyPutUint64(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_put_uint64(address,byte[],uint64)void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } + /** + * Constructs a no op call for the verify_put_bytes(address,byte[],byte[])void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyPutBytes(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_put_bytes(address,byte[],byte[])void' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b, params.args.c], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StateAppLocalContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAppLocalContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAppLocalContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAppLocalContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAppLocalContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAppLocalContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAppLocalContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAppLocalContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppLocalContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppLocalContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppLocalContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAppLocalContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAppLocalContract smart contract + */ +export class StateAppLocalContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAppLocalContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAppLocalContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAppLocalContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAppLocalContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAppLocalContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAppLocalContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAppLocalContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateAppLocalContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn params + */ + optIn: (params: CallParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + return this.appClient.params.optIn(StateAppLocalContractParamsFactory.optIn.optIn(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the StateAppLocalContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_bytes(address,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppLocalContractParamsFactory.verifyGetBytes(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_uint64(address,byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppLocalContractParamsFactory.verifyGetUint64(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_ex_bytes(address,uint64,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetExBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppLocalContractParamsFactory.verifyGetExBytes(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_ex_uint64(address,uint64,byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyGetExUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppLocalContractParamsFactory.verifyGetExUint64(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_delete(address,byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyDelete: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppLocalContractParamsFactory.verifyDelete(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_exists(address,byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyExists: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppLocalContractParamsFactory.verifyExists(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_put_uint64(address,byte[],uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyPutUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppLocalContractParamsFactory.verifyPutUint64(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_put_bytes(address,byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyPutBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppLocalContractParamsFactory.verifyPutBytes(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateAppLocalContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn transaction + */ + optIn: (params: CallParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + return this.appClient.createTransaction.optIn(StateAppLocalContractParamsFactory.optIn.optIn(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the StateAppLocalContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_bytes(address,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppLocalContractParamsFactory.verifyGetBytes(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_uint64(address,byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppLocalContractParamsFactory.verifyGetUint64(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_ex_bytes(address,uint64,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetExBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppLocalContractParamsFactory.verifyGetExBytes(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_ex_uint64(address,uint64,byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyGetExUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppLocalContractParamsFactory.verifyGetExUint64(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_delete(address,byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyDelete: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppLocalContractParamsFactory.verifyDelete(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_exists(address,byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyExists: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppLocalContractParamsFactory.verifyExists(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_put_uint64(address,byte[],uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyPutUint64: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppLocalContractParamsFactory.verifyPutUint64(params)) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_put_bytes(address,byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyPutBytes: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppLocalContractParamsFactory.verifyPutBytes(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateAppLocalContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn result + */ + optIn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + const result = await this.appClient.send.optIn(StateAppLocalContractParamsFactory.optIn.optIn(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['opt_in()void'])} + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the StateAppLocalContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_bytes(address,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppLocalContractParamsFactory.verifyGetBytes(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['verify_get_bytes(address,byte[])byte[]'])} + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_uint64(address,byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppLocalContractParamsFactory.verifyGetUint64(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['verify_get_uint64(address,byte[])uint64'])} + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_ex_bytes(address,uint64,byte[])byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetExBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppLocalContractParamsFactory.verifyGetExBytes(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['verify_get_ex_bytes(address,uint64,byte[])byte[]'])} + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_get_ex_uint64(address,uint64,byte[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyGetExUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppLocalContractParamsFactory.verifyGetExUint64(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['verify_get_ex_uint64(address,uint64,byte[])uint64'])} + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_delete(address,byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyDelete: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppLocalContractParamsFactory.verifyDelete(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['verify_delete(address,byte[])void'])} + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_exists(address,byte[])bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyExists: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppLocalContractParamsFactory.verifyExists(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['verify_exists(address,byte[])bool'])} + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_put_uint64(address,byte[],uint64)void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyPutUint64: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppLocalContractParamsFactory.verifyPutUint64(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['verify_put_uint64(address,byte[],uint64)void'])} + }, + + /** + * Makes a call to the StateAppLocalContract smart contract using the `verify_put_bytes(address,byte[],byte[])void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyPutBytes: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppLocalContractParamsFactory.verifyPutBytes(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalContractReturns['verify_put_bytes(address,byte[],byte[])void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAppLocalContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAppLocalContract app + */ + state = { + /** + * Methods to access local state for the current StateAppLocalContract app + */ + local: (address: string | Address) => { + const encodedAddress = typeof address === 'string' ? address : encodeAddress(address.publicKey) + return { + /** + * Get all current keyed values from local state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.local(encodedAddress).getAll() + return { + localUint64: result.local_uint64, + localBytes: new BinaryStateValue(result.local_bytes), + } + }, + /** + * Get the current value of the local_uint64 key in local state + */ + localUint64: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("local_uint64")) as bigint | undefined }, + /** + * Get the current value of the local_bytes key in local state + */ + localBytes: async (): Promise => { return new BinaryStateValue((await this.appClient.state.local(encodedAddress).getValue("local_bytes")) as Uint8Array | undefined) }, + } + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAppLocalContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_get_bytes(address,byte[])byte[] method call against the StateAppLocalContract contract + */ + verifyGetBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetBytes(params))) + return this + }, + /** + * Add a verify_get_uint64(address,byte[])uint64 method call against the StateAppLocalContract contract + */ + verifyGetUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetUint64(params))) + return this + }, + /** + * Add a verify_get_ex_bytes(address,uint64,byte[])byte[] method call against the StateAppLocalContract contract + */ + verifyGetExBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetExBytes(params))) + return this + }, + /** + * Add a verify_get_ex_uint64(address,uint64,byte[])uint64 method call against the StateAppLocalContract contract + */ + verifyGetExUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyGetExUint64(params))) + return this + }, + /** + * Add a verify_delete(address,byte[])void method call against the StateAppLocalContract contract + */ + verifyDelete(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyDelete(params))) + return this + }, + /** + * Add a verify_exists(address,byte[])bool method call against the StateAppLocalContract contract + */ + verifyExists(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyExists(params))) + return this + }, + /** + * Add a verify_put_uint64(address,byte[],uint64)void method call against the StateAppLocalContract contract + */ + verifyPutUint64(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyPutUint64(params))) + return this + }, + /** + * Add a verify_put_bytes(address,byte[],byte[])void method call against the StateAppLocalContract contract + */ + verifyPutBytes(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyPutBytes(params))) + return this + }, + get optIn() { + return { + optIn: (params: CallParams) => { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.optIn.optIn(params))) + return this + }, + } + }, + /** + * Add a clear state call to the StateAppLocalContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAppLocalContractComposer + } +} +export type StateAppLocalContractComposer = { + /** + * Calls the verify_get_bytes(address,byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetBytes(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['verify_get_bytes(address,byte[])byte[]'] | undefined]> + + /** + * Calls the verify_get_uint64(address,byte[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetUint64(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['verify_get_uint64(address,byte[])uint64'] | undefined]> + + /** + * Calls the verify_get_ex_bytes(address,uint64,byte[])byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetExBytes(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['verify_get_ex_bytes(address,uint64,byte[])byte[]'] | undefined]> + + /** + * Calls the verify_get_ex_uint64(address,uint64,byte[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyGetExUint64(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['verify_get_ex_uint64(address,uint64,byte[])uint64'] | undefined]> + + /** + * Calls the verify_delete(address,byte[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyDelete(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['verify_delete(address,byte[])void'] | undefined]> + + /** + * Calls the verify_exists(address,byte[])bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyExists(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['verify_exists(address,byte[])bool'] | undefined]> + + /** + * Calls the verify_put_uint64(address,byte[],uint64)void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyPutUint64(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['verify_put_uint64(address,byte[],uint64)void'] | undefined]> + + /** + * Calls the verify_put_bytes(address,byte[],byte[])void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyPutBytes(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['verify_put_bytes(address,byte[],byte[])void'] | undefined]> + + /** + * Gets available optIn methods + */ + readonly optIn: { + /** + * Opts the user into an existing instance of the StateAppLocalContract smart contract using the opt_in()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + optIn(params?: CallParams): StateAppLocalContractComposer<[...TReturns, StateAppLocalContractReturns['opt_in()void'] | undefined]> + } + + /** + * Makes a clear_state call to an existing instance of the StateAppLocalContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAppLocalContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAppLocalContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAppLocalContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAppLocalExContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppLocalExContract.ts new file mode 100644 index 0000000..53a53bd --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppLocalExContract.ts @@ -0,0 +1,635 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateAppLocalExContract","structs":{},"methods":[{"name":"opt_in","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["OptIn"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":1,"bytes":2}},"keys":{"global":{},"local":{"local_uint64":{"keyType":"AVMString","valueType":"AVMUint64","key":"bG9jYWxfdWludDY0"},"local_bytes":{"keyType":"AVMString","valueType":"AVMBytes","key":"bG9jYWxfYnl0ZXM="},"local_arc4_bytes":{"keyType":"AVMString","valueType":"byte[]","key":"bG9jYWxfYXJjNF9ieXRlcw=="}},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CzEbQQAagAQwxtWKNhoAjgEAAQAxGYEBEjEYEERCAAgxGRQxGBQQQzIJggILbG9jYWxfYnl0ZXMiZHVtbXlfYnl0ZXNfZnJvbV9leHRlcm5hbF9jb250cmFjdGYyCYAMbG9jYWxfdWludDY0gWNmMgmCAhBsb2NhbF9hcmM0X2J5dGVzEgAQZHVtbXlfYXJjNF9ieXRlc2aBAUM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAppLocalExContract contract + */ +export type StateAppLocalExContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'opt_in()void': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'opt_in()void': [] + } +} + +/** + * The return type for each method + */ +export type StateAppLocalExContractReturns = { + 'opt_in()void': void +} + +/** + * Defines the types of available calls and state of the StateAppLocalExContract smart contract. + */ +export type StateAppLocalExContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'opt_in()void' | 'opt_in', { + argsObj: StateAppLocalExContractArgs['obj']['opt_in()void'] + argsTuple: StateAppLocalExContractArgs['tuple']['opt_in()void'] + returns: StateAppLocalExContractReturns['opt_in()void'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + local: { + keys: { + localUint64: bigint + localBytes: BinaryState + localArc4Bytes: Uint8Array + } + maps: {} + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAppLocalExContractSignatures = keyof StateAppLocalExContractTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAppLocalExContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAppLocalExContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAppLocalExContract smart contract to the method's return type + */ +export type MethodReturn = StateAppLocalExContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed local state of the application. + */ +export type LocalKeysState = StateAppLocalExContractTypes['state']['local']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAppLocalExContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAppLocalExContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAppLocalExContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAppLocalExContract smart contract + */ +export abstract class StateAppLocalExContractParamsFactory { + /** + * Gets available optIn ABI call param factories + */ + static get optIn() { + return { + /** + * Constructs opt-in ABI call params for the StateAppLocalExContract smart contract using the opt_in()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + optIn(params: CallParams): AppClientMethodCallParams { + return { + ...params, + method: 'opt_in()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + }, + } + } + +} + +/** + * A factory to create and deploy one or more instance of the StateAppLocalExContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAppLocalExContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAppLocalExContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAppLocalExContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAppLocalExContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAppLocalExContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAppLocalExContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAppLocalExContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppLocalExContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppLocalExContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppLocalExContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAppLocalExContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAppLocalExContract smart contract + */ +export class StateAppLocalExContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAppLocalExContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAppLocalExContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAppLocalExContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAppLocalExContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAppLocalExContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAppLocalExContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAppLocalExContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateAppLocalExContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn params + */ + optIn: (params: CallParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + return this.appClient.params.optIn(StateAppLocalExContractParamsFactory.optIn.optIn(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the StateAppLocalExContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateAppLocalExContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn transaction + */ + optIn: (params: CallParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + return this.appClient.createTransaction.optIn(StateAppLocalExContractParamsFactory.optIn.optIn(params)) + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the StateAppLocalExContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateAppLocalExContract smart contract using the `opt_in()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The optIn result + */ + optIn: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.OptIn } = {args: []}) => { + const result = await this.appClient.send.optIn(StateAppLocalExContractParamsFactory.optIn.optIn(params)) + return {...result, return: result.return as unknown as (undefined | StateAppLocalExContractReturns['opt_in()void'])} + }, + + }, + + /** + * Makes a clear_state call to an existing instance of the StateAppLocalExContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAppLocalExContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAppLocalExContract app + */ + state = { + /** + * Methods to access local state for the current StateAppLocalExContract app + */ + local: (address: string | Address) => { + const encodedAddress = typeof address === 'string' ? address : encodeAddress(address.publicKey) + return { + /** + * Get all current keyed values from local state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.local(encodedAddress).getAll() + return { + localUint64: result.local_uint64, + localBytes: new BinaryStateValue(result.local_bytes), + localArc4Bytes: result.local_arc4_bytes, + } + }, + /** + * Get the current value of the local_uint64 key in local state + */ + localUint64: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("local_uint64")) as bigint | undefined }, + /** + * Get the current value of the local_bytes key in local state + */ + localBytes: async (): Promise => { return new BinaryStateValue((await this.appClient.state.local(encodedAddress).getValue("local_bytes")) as Uint8Array | undefined) }, + /** + * Get the current value of the local_arc4_bytes key in local state + */ + localArc4Bytes: async (): Promise => { return (await this.appClient.state.local(encodedAddress).getValue("local_arc4_bytes")) as Uint8Array | undefined }, + } + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAppLocalExContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + get optIn() { + return { + optIn: (params: CallParams) => { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.optIn.optIn(params))) + return this + }, + } + }, + /** + * Add a clear state call to the StateAppLocalExContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAppLocalExContractComposer + } +} +export type StateAppLocalExContractComposer = { + /** + * Gets available optIn methods + */ + readonly optIn: { + /** + * Opts the user into an existing instance of the StateAppLocalExContract smart contract using the opt_in()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + optIn(params?: CallParams): StateAppLocalExContractComposer<[...TReturns, StateAppLocalExContractReturns['opt_in()void'] | undefined]> + } + + /** + * Makes a clear_state call to an existing instance of the StateAppLocalExContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAppLocalExContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAppLocalExContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAppLocalExContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAppParamsContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppParamsContract.ts new file mode 100644 index 0000000..182a6a4 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAppParamsContract.ts @@ -0,0 +1,1112 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateAppParamsContract","structs":{},"methods":[{"name":"verify_app_params_get_approval_program","args":[{"type":"uint64","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_app_params_get_clear_state_program","args":[{"type":"uint64","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_app_params_get_global_num_uint","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_app_params_get_global_num_byte_slice","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_app_params_get_local_num_uint","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_app_params_get_local_num_byte_slice","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_app_params_get_extra_program_pages","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_app_params_get_creator","args":[{"type":"uint64","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_app_params_get_address","args":[{"type":"uint64","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[121,155,189,216,243,270,297,324,350],"errorMessage":"expected exists by index to match"},{"pc":[119,153,187,214,241,268,295,322,348],"errorMessage":"expected value by index to match"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@16
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0xb9d13c1b 0xe5c3c889 0xee4e7b2a 0x7fa234cb 0x19f77439 0x92c572aa 0xae9c6efb 0xe36ed705 0x8c66a842 // method "verify_app_params_get_approval_program(uint64)byte[]", method "verify_app_params_get_clear_state_program(uint64)byte[]", method "verify_app_params_get_global_num_uint(uint64)uint64", method "verify_app_params_get_global_num_byte_slice(uint64)uint64", method "verify_app_params_get_local_num_uint(uint64)uint64", method "verify_app_params_get_local_num_byte_slice(uint64)uint64", method "verify_app_params_get_extra_program_pages(uint64)uint64", method "verify_app_params_get_creator(uint64)address", method "verify_app_params_get_address(uint64)address"
    txna ApplicationArgs 0
    match verify_app_params_get_approval_program verify_app_params_get_clear_state_program verify_app_params_get_global_num_uint verify_app_params_get_global_num_byte_slice verify_app_params_get_local_num_uint verify_app_params_get_local_num_byte_slice verify_app_params_get_extra_program_pages verify_app_params_get_creator verify_app_params_get_address
    err

main___algopy_default_create@16:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_approval_program[routing]() -> void:
verify_app_params_get_approval_program:
    // tests/artifacts/StateOps/contract.py:273
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:275
    // value, exists = op.AppParamsGet.app_approval_program(a)
    app_params_get AppApprovalProgram
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:276
    // value_index, exists_index = op.AppParamsGet.app_approval_program(_get_1st_ref_index())
    app_params_get AppApprovalProgram
    // tests/artifacts/StateOps/contract.py:277
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:278
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:273
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_clear_state_program[routing]() -> void:
verify_app_params_get_clear_state_program:
    // tests/artifacts/StateOps/contract.py:281
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:283
    // value, exists = op.AppParamsGet.app_clear_state_program(a)
    app_params_get AppClearStateProgram
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:284
    // value_index, exists_index = op.AppParamsGet.app_clear_state_program(_get_1st_ref_index())
    app_params_get AppClearStateProgram
    // tests/artifacts/StateOps/contract.py:285
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:286
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:281
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_global_num_uint[routing]() -> void:
verify_app_params_get_global_num_uint:
    // tests/artifacts/StateOps/contract.py:289
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:291
    // value, exists = op.AppParamsGet.app_global_num_uint(a)
    app_params_get AppGlobalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:292
    // value_index, exists_index = op.AppParamsGet.app_global_num_uint(_get_1st_ref_index())
    app_params_get AppGlobalNumUint
    // tests/artifacts/StateOps/contract.py:293
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:294
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:289
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_global_num_byte_slice[routing]() -> void:
verify_app_params_get_global_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:297
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:299
    // value, exists = op.AppParamsGet.app_global_num_byte_slice(a)
    app_params_get AppGlobalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:300
    // value_index, exists_index = op.AppParamsGet.app_global_num_byte_slice(_get_1st_ref_index())
    app_params_get AppGlobalNumByteSlice
    // tests/artifacts/StateOps/contract.py:301
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:302
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:297
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_local_num_uint[routing]() -> void:
verify_app_params_get_local_num_uint:
    // tests/artifacts/StateOps/contract.py:305
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:307
    // value, exists = op.AppParamsGet.app_local_num_uint(a)
    app_params_get AppLocalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:308
    // value_index, exists_index = op.AppParamsGet.app_local_num_uint(_get_1st_ref_index())
    app_params_get AppLocalNumUint
    // tests/artifacts/StateOps/contract.py:309
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:310
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:305
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_local_num_byte_slice[routing]() -> void:
verify_app_params_get_local_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:313
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:315
    // value, exists = op.AppParamsGet.app_local_num_byte_slice(a)
    app_params_get AppLocalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:316
    // value_index, exists_index = op.AppParamsGet.app_local_num_byte_slice(_get_1st_ref_index())
    app_params_get AppLocalNumByteSlice
    // tests/artifacts/StateOps/contract.py:317
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:318
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:313
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_extra_program_pages[routing]() -> void:
verify_app_params_get_extra_program_pages:
    // tests/artifacts/StateOps/contract.py:321
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:323
    // value, exists = op.AppParamsGet.app_extra_program_pages(a)
    app_params_get AppExtraProgramPages
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:324
    // value_index, exists_index = op.AppParamsGet.app_extra_program_pages(_get_1st_ref_index())
    app_params_get AppExtraProgramPages
    // tests/artifacts/StateOps/contract.py:325
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:326
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:321
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_creator[routing]() -> void:
verify_app_params_get_creator:
    // tests/artifacts/StateOps/contract.py:329
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:331
    // value, exists = op.AppParamsGet.app_creator(a)
    app_params_get AppCreator
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:332
    // value_index, exists_index = op.AppParamsGet.app_creator(_get_1st_ref_index())
    app_params_get AppCreator
    // tests/artifacts/StateOps/contract.py:333
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:334
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:329
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_address[routing]() -> void:
verify_app_params_get_address:
    // tests/artifacts/StateOps/contract.py:337
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:339
    // value, exists = op.AppParamsGet.app_address(a)
    app_params_get AppAddress
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:340
    // value_index, exists_index = op.AppParamsGet.app_address(_get_1st_ref_index())
    app_params_get AppAddress
    // tests/artifacts/StateOps/contract.py:341
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:342
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:337
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyABASYBBBUffHUxG0EATjEZFEQxGESCCQS50TwbBOXDyIkE7k57KgR/ojTLBBn3dDkEksVyqgSunG77BONu1wUEjGaoQjYaAI4JAAkAKwBNAGgAgwCeALkA1ADuADEZFDEYFBBDNhoBF3IANhoBF3IASwNPAhJEEkRJFRZXBgJMUChMULAiQzYaARdyATYaARdyAUsDTwISRBJESRUWVwYCTFAoTFCwIkM2GgEXcgI2GgEXcgJLA08CEkQSRBYoTFCwIkM2GgEXcgM2GgEXcgNLA08CEkQSRBYoTFCwIkM2GgEXcgQ2GgEXcgRLA08CEkQSRBYoTFCwIkM2GgEXcgU2GgEXcgVLA08CEkQSRBYoTFCwIkM2GgEXcgY2GgEXcgZLA08CEkQSRBYoTFCwIkM2GgEXcgc2GgEXcgdLA08CEkQSRChMULAiQzYaARdyCDYaARdyCEsDTwISRBJEKExQsCJD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAppParamsContract contract + */ +export type StateAppParamsContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_app_params_get_approval_program(uint64)byte[]': { + a: bigint | number + } + 'verify_app_params_get_clear_state_program(uint64)byte[]': { + a: bigint | number + } + 'verify_app_params_get_global_num_uint(uint64)uint64': { + a: bigint | number + } + 'verify_app_params_get_global_num_byte_slice(uint64)uint64': { + a: bigint | number + } + 'verify_app_params_get_local_num_uint(uint64)uint64': { + a: bigint | number + } + 'verify_app_params_get_local_num_byte_slice(uint64)uint64': { + a: bigint | number + } + 'verify_app_params_get_extra_program_pages(uint64)uint64': { + a: bigint | number + } + 'verify_app_params_get_creator(uint64)address': { + a: bigint | number + } + 'verify_app_params_get_address(uint64)address': { + a: bigint | number + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_app_params_get_approval_program(uint64)byte[]': [a: bigint | number] + 'verify_app_params_get_clear_state_program(uint64)byte[]': [a: bigint | number] + 'verify_app_params_get_global_num_uint(uint64)uint64': [a: bigint | number] + 'verify_app_params_get_global_num_byte_slice(uint64)uint64': [a: bigint | number] + 'verify_app_params_get_local_num_uint(uint64)uint64': [a: bigint | number] + 'verify_app_params_get_local_num_byte_slice(uint64)uint64': [a: bigint | number] + 'verify_app_params_get_extra_program_pages(uint64)uint64': [a: bigint | number] + 'verify_app_params_get_creator(uint64)address': [a: bigint | number] + 'verify_app_params_get_address(uint64)address': [a: bigint | number] + } +} + +/** + * The return type for each method + */ +export type StateAppParamsContractReturns = { + 'verify_app_params_get_approval_program(uint64)byte[]': Uint8Array + 'verify_app_params_get_clear_state_program(uint64)byte[]': Uint8Array + 'verify_app_params_get_global_num_uint(uint64)uint64': bigint + 'verify_app_params_get_global_num_byte_slice(uint64)uint64': bigint + 'verify_app_params_get_local_num_uint(uint64)uint64': bigint + 'verify_app_params_get_local_num_byte_slice(uint64)uint64': bigint + 'verify_app_params_get_extra_program_pages(uint64)uint64': bigint + 'verify_app_params_get_creator(uint64)address': string + 'verify_app_params_get_address(uint64)address': string +} + +/** + * Defines the types of available calls and state of the StateAppParamsContract smart contract. + */ +export type StateAppParamsContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_app_params_get_approval_program(uint64)byte[]' | 'verify_app_params_get_approval_program', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_approval_program(uint64)byte[]'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_approval_program(uint64)byte[]'] + returns: StateAppParamsContractReturns['verify_app_params_get_approval_program(uint64)byte[]'] + }> + & Record<'verify_app_params_get_clear_state_program(uint64)byte[]' | 'verify_app_params_get_clear_state_program', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_clear_state_program(uint64)byte[]'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_clear_state_program(uint64)byte[]'] + returns: StateAppParamsContractReturns['verify_app_params_get_clear_state_program(uint64)byte[]'] + }> + & Record<'verify_app_params_get_global_num_uint(uint64)uint64' | 'verify_app_params_get_global_num_uint', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_global_num_uint(uint64)uint64'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_global_num_uint(uint64)uint64'] + returns: StateAppParamsContractReturns['verify_app_params_get_global_num_uint(uint64)uint64'] + }> + & Record<'verify_app_params_get_global_num_byte_slice(uint64)uint64' | 'verify_app_params_get_global_num_byte_slice', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_global_num_byte_slice(uint64)uint64'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_global_num_byte_slice(uint64)uint64'] + returns: StateAppParamsContractReturns['verify_app_params_get_global_num_byte_slice(uint64)uint64'] + }> + & Record<'verify_app_params_get_local_num_uint(uint64)uint64' | 'verify_app_params_get_local_num_uint', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_local_num_uint(uint64)uint64'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_local_num_uint(uint64)uint64'] + returns: StateAppParamsContractReturns['verify_app_params_get_local_num_uint(uint64)uint64'] + }> + & Record<'verify_app_params_get_local_num_byte_slice(uint64)uint64' | 'verify_app_params_get_local_num_byte_slice', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_local_num_byte_slice(uint64)uint64'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_local_num_byte_slice(uint64)uint64'] + returns: StateAppParamsContractReturns['verify_app_params_get_local_num_byte_slice(uint64)uint64'] + }> + & Record<'verify_app_params_get_extra_program_pages(uint64)uint64' | 'verify_app_params_get_extra_program_pages', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_extra_program_pages(uint64)uint64'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_extra_program_pages(uint64)uint64'] + returns: StateAppParamsContractReturns['verify_app_params_get_extra_program_pages(uint64)uint64'] + }> + & Record<'verify_app_params_get_creator(uint64)address' | 'verify_app_params_get_creator', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_creator(uint64)address'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_creator(uint64)address'] + returns: StateAppParamsContractReturns['verify_app_params_get_creator(uint64)address'] + }> + & Record<'verify_app_params_get_address(uint64)address' | 'verify_app_params_get_address', { + argsObj: StateAppParamsContractArgs['obj']['verify_app_params_get_address(uint64)address'] + argsTuple: StateAppParamsContractArgs['tuple']['verify_app_params_get_address(uint64)address'] + returns: StateAppParamsContractReturns['verify_app_params_get_address(uint64)address'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAppParamsContractSignatures = keyof StateAppParamsContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StateAppParamsContractNonVoidMethodSignatures = keyof StateAppParamsContractTypes['methods'] extends infer T ? T extends keyof StateAppParamsContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAppParamsContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAppParamsContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAppParamsContract smart contract to the method's return type + */ +export type MethodReturn = StateAppParamsContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAppParamsContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAppParamsContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAppParamsContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAppParamsContract smart contract + */ +export abstract class StateAppParamsContractParamsFactory { + /** + * Constructs a no op call for the verify_app_params_get_approval_program(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetApprovalProgram(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_approval_program(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_app_params_get_clear_state_program(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetClearStateProgram(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_clear_state_program(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_app_params_get_global_num_uint(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetGlobalNumUint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_global_num_uint(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_app_params_get_global_num_byte_slice(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetGlobalNumByteSlice(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_global_num_byte_slice(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_app_params_get_local_num_uint(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetLocalNumUint(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_local_num_uint(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_app_params_get_local_num_byte_slice(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetLocalNumByteSlice(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_local_num_byte_slice(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_app_params_get_extra_program_pages(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetExtraProgramPages(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_extra_program_pages(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_app_params_get_creator(uint64)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetCreator(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_creator(uint64)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_app_params_get_address(uint64)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAppParamsGetAddress(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_app_params_get_address(uint64)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StateAppParamsContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAppParamsContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAppParamsContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAppParamsContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAppParamsContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAppParamsContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAppParamsContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAppParamsContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppParamsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppParamsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAppParamsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAppParamsContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAppParamsContract smart contract + */ +export class StateAppParamsContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAppParamsContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAppParamsContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAppParamsContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAppParamsContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAppParamsContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAppParamsContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAppParamsContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the StateAppParamsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_approval_program(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetApprovalProgram: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetApprovalProgram(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_clear_state_program(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetClearStateProgram: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetClearStateProgram(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_global_num_uint(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetGlobalNumUint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetGlobalNumUint(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_global_num_byte_slice(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetGlobalNumByteSlice: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetGlobalNumByteSlice(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_local_num_uint(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetLocalNumUint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetLocalNumUint(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_local_num_byte_slice(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetLocalNumByteSlice: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetLocalNumByteSlice(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_extra_program_pages(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetExtraProgramPages: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetExtraProgramPages(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_creator(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetCreator: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetCreator(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_address(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAppParamsGetAddress: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAppParamsContractParamsFactory.verifyAppParamsGetAddress(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the StateAppParamsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_approval_program(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetApprovalProgram: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetApprovalProgram(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_clear_state_program(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetClearStateProgram: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetClearStateProgram(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_global_num_uint(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetGlobalNumUint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetGlobalNumUint(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_global_num_byte_slice(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetGlobalNumByteSlice: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetGlobalNumByteSlice(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_local_num_uint(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetLocalNumUint: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetLocalNumUint(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_local_num_byte_slice(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetLocalNumByteSlice: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetLocalNumByteSlice(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_extra_program_pages(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetExtraProgramPages: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetExtraProgramPages(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_creator(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetCreator: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetCreator(params)) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_address(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAppParamsGetAddress: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAppParamsContractParamsFactory.verifyAppParamsGetAddress(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the StateAppParamsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_approval_program(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetApprovalProgram: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetApprovalProgram(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_approval_program(uint64)byte[]'])} + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_clear_state_program(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetClearStateProgram: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetClearStateProgram(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_clear_state_program(uint64)byte[]'])} + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_global_num_uint(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetGlobalNumUint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetGlobalNumUint(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_global_num_uint(uint64)uint64'])} + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_global_num_byte_slice(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetGlobalNumByteSlice: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetGlobalNumByteSlice(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_global_num_byte_slice(uint64)uint64'])} + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_local_num_uint(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetLocalNumUint: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetLocalNumUint(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_local_num_uint(uint64)uint64'])} + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_local_num_byte_slice(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetLocalNumByteSlice: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetLocalNumByteSlice(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_local_num_byte_slice(uint64)uint64'])} + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_extra_program_pages(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetExtraProgramPages: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetExtraProgramPages(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_extra_program_pages(uint64)uint64'])} + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_creator(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetCreator: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetCreator(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_creator(uint64)address'])} + }, + + /** + * Makes a call to the StateAppParamsContract smart contract using the `verify_app_params_get_address(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAppParamsGetAddress: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAppParamsContractParamsFactory.verifyAppParamsGetAddress(params)) + return {...result, return: result.return as unknown as (undefined | StateAppParamsContractReturns['verify_app_params_get_address(uint64)address'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAppParamsContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAppParamsContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAppParamsContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_app_params_get_approval_program(uint64)byte[] method call against the StateAppParamsContract contract + */ + verifyAppParamsGetApprovalProgram(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetApprovalProgram(params))) + return this + }, + /** + * Add a verify_app_params_get_clear_state_program(uint64)byte[] method call against the StateAppParamsContract contract + */ + verifyAppParamsGetClearStateProgram(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetClearStateProgram(params))) + return this + }, + /** + * Add a verify_app_params_get_global_num_uint(uint64)uint64 method call against the StateAppParamsContract contract + */ + verifyAppParamsGetGlobalNumUint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetGlobalNumUint(params))) + return this + }, + /** + * Add a verify_app_params_get_global_num_byte_slice(uint64)uint64 method call against the StateAppParamsContract contract + */ + verifyAppParamsGetGlobalNumByteSlice(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetGlobalNumByteSlice(params))) + return this + }, + /** + * Add a verify_app_params_get_local_num_uint(uint64)uint64 method call against the StateAppParamsContract contract + */ + verifyAppParamsGetLocalNumUint(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetLocalNumUint(params))) + return this + }, + /** + * Add a verify_app_params_get_local_num_byte_slice(uint64)uint64 method call against the StateAppParamsContract contract + */ + verifyAppParamsGetLocalNumByteSlice(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetLocalNumByteSlice(params))) + return this + }, + /** + * Add a verify_app_params_get_extra_program_pages(uint64)uint64 method call against the StateAppParamsContract contract + */ + verifyAppParamsGetExtraProgramPages(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetExtraProgramPages(params))) + return this + }, + /** + * Add a verify_app_params_get_creator(uint64)address method call against the StateAppParamsContract contract + */ + verifyAppParamsGetCreator(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetCreator(params))) + return this + }, + /** + * Add a verify_app_params_get_address(uint64)address method call against the StateAppParamsContract contract + */ + verifyAppParamsGetAddress(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAppParamsGetAddress(params))) + return this + }, + /** + * Add a clear state call to the StateAppParamsContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAppParamsContractComposer + } +} +export type StateAppParamsContractComposer = { + /** + * Calls the verify_app_params_get_approval_program(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetApprovalProgram(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_approval_program(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_app_params_get_clear_state_program(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetClearStateProgram(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_clear_state_program(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_app_params_get_global_num_uint(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetGlobalNumUint(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_global_num_uint(uint64)uint64'] | undefined]> + + /** + * Calls the verify_app_params_get_global_num_byte_slice(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetGlobalNumByteSlice(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_global_num_byte_slice(uint64)uint64'] | undefined]> + + /** + * Calls the verify_app_params_get_local_num_uint(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetLocalNumUint(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_local_num_uint(uint64)uint64'] | undefined]> + + /** + * Calls the verify_app_params_get_local_num_byte_slice(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetLocalNumByteSlice(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_local_num_byte_slice(uint64)uint64'] | undefined]> + + /** + * Calls the verify_app_params_get_extra_program_pages(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetExtraProgramPages(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_extra_program_pages(uint64)uint64'] | undefined]> + + /** + * Calls the verify_app_params_get_creator(uint64)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetCreator(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_creator(uint64)address'] | undefined]> + + /** + * Calls the verify_app_params_get_address(uint64)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAppParamsGetAddress(params?: CallParams): StateAppParamsContractComposer<[...TReturns, StateAppParamsContractReturns['verify_app_params_get_address(uint64)address'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the StateAppParamsContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAppParamsContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAppParamsContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAppParamsContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAssetHoldingContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAssetHoldingContract.ts new file mode 100644 index 0000000..c46961a --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAssetHoldingContract.ts @@ -0,0 +1,631 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateAssetHoldingContract","structs":{},"methods":[{"name":"verify_asset_holding_get","args":[{"type":"address","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_frozen_get","args":[{"type":"address","name":"a"},{"type":"uint64","name":"b"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyYBBBUffHUxG0EAHTEZFEQxGESCAgSPUjW0BN56OfY2GgCOAgAJABsAMRkUMRgUEEM2GgE2GgIXcABIFihMULCBAUM2GgE2GgIXcAFIgAEAgQBPAlQoTFCwgQFD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAssetHoldingContract contract + */ +export type StateAssetHoldingContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_asset_holding_get(address,uint64)uint64': { + a: string + b: bigint | number + } + 'verify_asset_frozen_get(address,uint64)bool': { + a: string + b: bigint | number + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_asset_holding_get(address,uint64)uint64': [a: string, b: bigint | number] + 'verify_asset_frozen_get(address,uint64)bool': [a: string, b: bigint | number] + } +} + +/** + * The return type for each method + */ +export type StateAssetHoldingContractReturns = { + 'verify_asset_holding_get(address,uint64)uint64': bigint + 'verify_asset_frozen_get(address,uint64)bool': boolean +} + +/** + * Defines the types of available calls and state of the StateAssetHoldingContract smart contract. + */ +export type StateAssetHoldingContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_asset_holding_get(address,uint64)uint64' | 'verify_asset_holding_get', { + argsObj: StateAssetHoldingContractArgs['obj']['verify_asset_holding_get(address,uint64)uint64'] + argsTuple: StateAssetHoldingContractArgs['tuple']['verify_asset_holding_get(address,uint64)uint64'] + returns: StateAssetHoldingContractReturns['verify_asset_holding_get(address,uint64)uint64'] + }> + & Record<'verify_asset_frozen_get(address,uint64)bool' | 'verify_asset_frozen_get', { + argsObj: StateAssetHoldingContractArgs['obj']['verify_asset_frozen_get(address,uint64)bool'] + argsTuple: StateAssetHoldingContractArgs['tuple']['verify_asset_frozen_get(address,uint64)bool'] + returns: StateAssetHoldingContractReturns['verify_asset_frozen_get(address,uint64)bool'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAssetHoldingContractSignatures = keyof StateAssetHoldingContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StateAssetHoldingContractNonVoidMethodSignatures = keyof StateAssetHoldingContractTypes['methods'] extends infer T ? T extends keyof StateAssetHoldingContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAssetHoldingContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAssetHoldingContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAssetHoldingContract smart contract to the method's return type + */ +export type MethodReturn = StateAssetHoldingContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAssetHoldingContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAssetHoldingContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAssetHoldingContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAssetHoldingContract smart contract + */ +export abstract class StateAssetHoldingContractParamsFactory { + /** + * Constructs a no op call for the verify_asset_holding_get(address,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetHoldingGet(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_holding_get(address,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } + /** + * Constructs a no op call for the verify_asset_frozen_get(address,uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetFrozenGet(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_frozen_get(address,uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a, params.args.b], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StateAssetHoldingContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAssetHoldingContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAssetHoldingContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAssetHoldingContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAssetHoldingContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAssetHoldingContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAssetHoldingContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAssetHoldingContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAssetHoldingContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAssetHoldingContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAssetHoldingContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAssetHoldingContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAssetHoldingContract smart contract + */ +export class StateAssetHoldingContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAssetHoldingContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAssetHoldingContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAssetHoldingContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAssetHoldingContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAssetHoldingContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAssetHoldingContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAssetHoldingContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the StateAssetHoldingContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StateAssetHoldingContract smart contract using the `verify_asset_holding_get(address,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetHoldingGet: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetHoldingContractParamsFactory.verifyAssetHoldingGet(params)) + }, + + /** + * Makes a call to the StateAssetHoldingContract smart contract using the `verify_asset_frozen_get(address,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetFrozenGet: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetHoldingContractParamsFactory.verifyAssetFrozenGet(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the StateAssetHoldingContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StateAssetHoldingContract smart contract using the `verify_asset_holding_get(address,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetHoldingGet: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetHoldingContractParamsFactory.verifyAssetHoldingGet(params)) + }, + + /** + * Makes a call to the StateAssetHoldingContract smart contract using the `verify_asset_frozen_get(address,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetFrozenGet: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetHoldingContractParamsFactory.verifyAssetFrozenGet(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the StateAssetHoldingContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StateAssetHoldingContract smart contract using the `verify_asset_holding_get(address,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetHoldingGet: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetHoldingContractParamsFactory.verifyAssetHoldingGet(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetHoldingContractReturns['verify_asset_holding_get(address,uint64)uint64'])} + }, + + /** + * Makes a call to the StateAssetHoldingContract smart contract using the `verify_asset_frozen_get(address,uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetFrozenGet: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetHoldingContractParamsFactory.verifyAssetFrozenGet(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetHoldingContractReturns['verify_asset_frozen_get(address,uint64)bool'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAssetHoldingContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAssetHoldingContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAssetHoldingContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_asset_holding_get(address,uint64)uint64 method call against the StateAssetHoldingContract contract + */ + verifyAssetHoldingGet(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetHoldingGet(params))) + return this + }, + /** + * Add a verify_asset_frozen_get(address,uint64)bool method call against the StateAssetHoldingContract contract + */ + verifyAssetFrozenGet(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetFrozenGet(params))) + return this + }, + /** + * Add a clear state call to the StateAssetHoldingContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAssetHoldingContractComposer + } +} +export type StateAssetHoldingContractComposer = { + /** + * Calls the verify_asset_holding_get(address,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetHoldingGet(params?: CallParams): StateAssetHoldingContractComposer<[...TReturns, StateAssetHoldingContractReturns['verify_asset_holding_get(address,uint64)uint64'] | undefined]> + + /** + * Calls the verify_asset_frozen_get(address,uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetFrozenGet(params?: CallParams): StateAssetHoldingContractComposer<[...TReturns, StateAssetHoldingContractReturns['verify_asset_frozen_get(address,uint64)bool'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the StateAssetHoldingContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAssetHoldingContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAssetHoldingContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAssetHoldingContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateAssetParamsContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateAssetParamsContract.ts new file mode 100644 index 0000000..b627ecf --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateAssetParamsContract.ts @@ -0,0 +1,1319 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateAssetParamsContract","structs":{},"methods":[{"name":"verify_asset_params_get_total","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_decimals","args":[{"type":"uint64","name":"a"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_default_frozen","args":[{"type":"uint64","name":"a"}],"returns":{"type":"bool"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_unit_name","args":[{"type":"uint64","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_name","args":[{"type":"uint64","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_url","args":[{"type":"uint64","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_metadata_hash","args":[{"type":"uint64","name":"a"}],"returns":{"type":"byte[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_manager","args":[{"type":"uint64","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_reserve","args":[{"type":"uint64","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_freeze","args":[{"type":"uint64","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_clawback","args":[{"type":"uint64","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"verify_asset_params_get_creator","args":[{"type":"uint64","name":"a"}],"returns":{"type":"address"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[142,169,196,230,264,298,332,366,392,418,444,470],"errorMessage":"expected exists by index to match"},{"pc":[140,167,194,228,262,296,330,364,390,416,442,468],"errorMessage":"expected value by index to match"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@19
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0xf05da7a4 0xc0e9c315 0xd8528273 0xf4468ad9 0x229d12f7 0xdf534f7b 0xe050b5a9 0x8b2a2d58 0xee15c4f7 0x157544ff 0x10492c07 0x5229fa37 // method "verify_asset_params_get_total(uint64)uint64", method "verify_asset_params_get_decimals(uint64)uint64", method "verify_asset_params_get_default_frozen(uint64)bool", method "verify_asset_params_get_unit_name(uint64)byte[]", method "verify_asset_params_get_name(uint64)byte[]", method "verify_asset_params_get_url(uint64)byte[]", method "verify_asset_params_get_metadata_hash(uint64)byte[]", method "verify_asset_params_get_manager(uint64)address", method "verify_asset_params_get_reserve(uint64)address", method "verify_asset_params_get_freeze(uint64)address", method "verify_asset_params_get_clawback(uint64)address", method "verify_asset_params_get_creator(uint64)address"
    txna ApplicationArgs 0
    match verify_asset_params_get_total verify_asset_params_get_decimals verify_asset_params_get_default_frozen verify_asset_params_get_unit_name verify_asset_params_get_name verify_asset_params_get_url verify_asset_params_get_metadata_hash verify_asset_params_get_manager verify_asset_params_get_reserve verify_asset_params_get_freeze verify_asset_params_get_clawback verify_asset_params_get_creator
    err

main___algopy_default_create@19:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_total[routing]() -> void:
verify_asset_params_get_total:
    // tests/artifacts/StateOps/contract.py:175
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:177
    // value, exists = op.AssetParamsGet.asset_total(a)
    asset_params_get AssetTotal
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:178
    // value_index, exists_index = op.AssetParamsGet.asset_total(_get_1st_ref_index())
    asset_params_get AssetTotal
    // tests/artifacts/StateOps/contract.py:179
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:180
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:175
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_decimals[routing]() -> void:
verify_asset_params_get_decimals:
    // tests/artifacts/StateOps/contract.py:183
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:185
    // value, exists = op.AssetParamsGet.asset_decimals(a)
    asset_params_get AssetDecimals
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:186
    // value_index, exists_index = op.AssetParamsGet.asset_decimals(_get_1st_ref_index())
    asset_params_get AssetDecimals
    // tests/artifacts/StateOps/contract.py:187
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:188
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:183
    // @arc4.abimethod()
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_default_frozen[routing]() -> void:
verify_asset_params_get_default_frozen:
    // tests/artifacts/StateOps/contract.py:191
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:193
    // value, exists = op.AssetParamsGet.asset_default_frozen(a)
    asset_params_get AssetDefaultFrozen
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:194
    // value_index, exists_index = op.AssetParamsGet.asset_default_frozen(_get_1st_ref_index())
    asset_params_get AssetDefaultFrozen
    // tests/artifacts/StateOps/contract.py:195
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:196
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:191
    // @arc4.abimethod()
    pushbytes 0x00
    pushint 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_unit_name[routing]() -> void:
verify_asset_params_get_unit_name:
    // tests/artifacts/StateOps/contract.py:199
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:201
    // value, exists = op.AssetParamsGet.asset_unit_name(a)
    asset_params_get AssetUnitName
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:202
    // value_index, exists_index = op.AssetParamsGet.asset_unit_name(_get_1st_ref_index())
    asset_params_get AssetUnitName
    // tests/artifacts/StateOps/contract.py:203
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:204
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:199
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_name[routing]() -> void:
verify_asset_params_get_name:
    // tests/artifacts/StateOps/contract.py:207
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:209
    // value, exists = op.AssetParamsGet.asset_name(a)
    asset_params_get AssetName
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:210
    // value_index, exists_index = op.AssetParamsGet.asset_name(_get_1st_ref_index())
    asset_params_get AssetName
    // tests/artifacts/StateOps/contract.py:211
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:212
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:207
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_url[routing]() -> void:
verify_asset_params_get_url:
    // tests/artifacts/StateOps/contract.py:215
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:217
    // value, exists = op.AssetParamsGet.asset_url(a)
    asset_params_get AssetURL
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:218
    // value_index, exists_index = op.AssetParamsGet.asset_url(_get_1st_ref_index())
    asset_params_get AssetURL
    // tests/artifacts/StateOps/contract.py:219
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:220
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:215
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_metadata_hash[routing]() -> void:
verify_asset_params_get_metadata_hash:
    // tests/artifacts/StateOps/contract.py:223
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:225
    // value, exists = op.AssetParamsGet.asset_metadata_hash(a)
    asset_params_get AssetMetadataHash
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:226
    // value_index, exists_index = op.AssetParamsGet.asset_metadata_hash(_get_1st_ref_index())
    asset_params_get AssetMetadataHash
    // tests/artifacts/StateOps/contract.py:227
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:228
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:223
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_manager[routing]() -> void:
verify_asset_params_get_manager:
    // tests/artifacts/StateOps/contract.py:231
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:233
    // value, exists = op.AssetParamsGet.asset_manager(a)
    asset_params_get AssetManager
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:234
    // value_index, exists_index = op.AssetParamsGet.asset_manager(_get_1st_ref_index())
    asset_params_get AssetManager
    // tests/artifacts/StateOps/contract.py:235
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:236
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:231
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_reserve[routing]() -> void:
verify_asset_params_get_reserve:
    // tests/artifacts/StateOps/contract.py:239
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:241
    // value, exists = op.AssetParamsGet.asset_reserve(a)
    asset_params_get AssetReserve
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:242
    // value_index, exists_index = op.AssetParamsGet.asset_reserve(_get_1st_ref_index())
    asset_params_get AssetReserve
    // tests/artifacts/StateOps/contract.py:243
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:244
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:239
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_freeze[routing]() -> void:
verify_asset_params_get_freeze:
    // tests/artifacts/StateOps/contract.py:247
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:249
    // value, exists = op.AssetParamsGet.asset_freeze(a)
    asset_params_get AssetFreeze
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:250
    // value_index, exists_index = op.AssetParamsGet.asset_freeze(_get_1st_ref_index())
    asset_params_get AssetFreeze
    // tests/artifacts/StateOps/contract.py:251
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:252
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:247
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_clawback[routing]() -> void:
verify_asset_params_get_clawback:
    // tests/artifacts/StateOps/contract.py:255
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:257
    // value, exists = op.AssetParamsGet.asset_clawback(a)
    asset_params_get AssetClawback
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:258
    // value_index, exists_index = op.AssetParamsGet.asset_clawback(_get_1st_ref_index())
    asset_params_get AssetClawback
    // tests/artifacts/StateOps/contract.py:259
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:260
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:255
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_creator[routing]() -> void:
verify_asset_params_get_creator:
    // tests/artifacts/StateOps/contract.py:263
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:265
    // value, exists = op.AssetParamsGet.asset_creator(a)
    asset_params_get AssetCreator
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:266
    // value_index, exists_index = op.AssetParamsGet.asset_creator(_get_1st_ref_index())
    asset_params_get AssetCreator
    // tests/artifacts/StateOps/contract.py:267
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:268
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:263
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyABASYBBBUffHUxG0EAYzEZFEQxGESCDATwXaekBMDpwxUE2FKCcwT0RorZBCKdEvcE31NPewTgULWpBIsqLVgE7hXE9wQVdUT/BBBJLAcEUin6NzYaAI4MAAkAJAA/AGEAgwClAMcA6QEDAR0BNwFRADEZFDEYFBBDNhoBF3EANhoBF3EASwNPAhJEEkQWKExQsCJDNhoBF3EBNhoBF3EBSwNPAhJEEkQWKExQsCJDNhoBF3ECNhoBF3ECSwNPAhJEEkSAAQCBAE8CVChMULAiQzYaARdxAzYaARdxA0sDTwISRBJESRUWVwYCTFAoTFCwIkM2GgEXcQQ2GgEXcQRLA08CEkQSREkVFlcGAkxQKExQsCJDNhoBF3EFNhoBF3EFSwNPAhJEEkRJFRZXBgJMUChMULAiQzYaARdxBjYaARdxBksDTwISRBJESRUWVwYCTFAoTFCwIkM2GgEXcQc2GgEXcQdLA08CEkQSRChMULAiQzYaARdxCDYaARdxCEsDTwISRBJEKExQsCJDNhoBF3EJNhoBF3EJSwNPAhJEEkQoTFCwIkM2GgEXcQo2GgEXcQpLA08CEkQSRChMULAiQzYaARdxCzYaARdxC0sDTwISRBJEKExQsCJD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateAssetParamsContract contract + */ +export type StateAssetParamsContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify_asset_params_get_total(uint64)uint64': { + a: bigint | number + } + 'verify_asset_params_get_decimals(uint64)uint64': { + a: bigint | number + } + 'verify_asset_params_get_default_frozen(uint64)bool': { + a: bigint | number + } + 'verify_asset_params_get_unit_name(uint64)byte[]': { + a: bigint | number + } + 'verify_asset_params_get_name(uint64)byte[]': { + a: bigint | number + } + 'verify_asset_params_get_url(uint64)byte[]': { + a: bigint | number + } + 'verify_asset_params_get_metadata_hash(uint64)byte[]': { + a: bigint | number + } + 'verify_asset_params_get_manager(uint64)address': { + a: bigint | number + } + 'verify_asset_params_get_reserve(uint64)address': { + a: bigint | number + } + 'verify_asset_params_get_freeze(uint64)address': { + a: bigint | number + } + 'verify_asset_params_get_clawback(uint64)address': { + a: bigint | number + } + 'verify_asset_params_get_creator(uint64)address': { + a: bigint | number + } + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify_asset_params_get_total(uint64)uint64': [a: bigint | number] + 'verify_asset_params_get_decimals(uint64)uint64': [a: bigint | number] + 'verify_asset_params_get_default_frozen(uint64)bool': [a: bigint | number] + 'verify_asset_params_get_unit_name(uint64)byte[]': [a: bigint | number] + 'verify_asset_params_get_name(uint64)byte[]': [a: bigint | number] + 'verify_asset_params_get_url(uint64)byte[]': [a: bigint | number] + 'verify_asset_params_get_metadata_hash(uint64)byte[]': [a: bigint | number] + 'verify_asset_params_get_manager(uint64)address': [a: bigint | number] + 'verify_asset_params_get_reserve(uint64)address': [a: bigint | number] + 'verify_asset_params_get_freeze(uint64)address': [a: bigint | number] + 'verify_asset_params_get_clawback(uint64)address': [a: bigint | number] + 'verify_asset_params_get_creator(uint64)address': [a: bigint | number] + } +} + +/** + * The return type for each method + */ +export type StateAssetParamsContractReturns = { + 'verify_asset_params_get_total(uint64)uint64': bigint + 'verify_asset_params_get_decimals(uint64)uint64': bigint + 'verify_asset_params_get_default_frozen(uint64)bool': boolean + 'verify_asset_params_get_unit_name(uint64)byte[]': Uint8Array + 'verify_asset_params_get_name(uint64)byte[]': Uint8Array + 'verify_asset_params_get_url(uint64)byte[]': Uint8Array + 'verify_asset_params_get_metadata_hash(uint64)byte[]': Uint8Array + 'verify_asset_params_get_manager(uint64)address': string + 'verify_asset_params_get_reserve(uint64)address': string + 'verify_asset_params_get_freeze(uint64)address': string + 'verify_asset_params_get_clawback(uint64)address': string + 'verify_asset_params_get_creator(uint64)address': string +} + +/** + * Defines the types of available calls and state of the StateAssetParamsContract smart contract. + */ +export type StateAssetParamsContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify_asset_params_get_total(uint64)uint64' | 'verify_asset_params_get_total', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_total(uint64)uint64'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_total(uint64)uint64'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_total(uint64)uint64'] + }> + & Record<'verify_asset_params_get_decimals(uint64)uint64' | 'verify_asset_params_get_decimals', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_decimals(uint64)uint64'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_decimals(uint64)uint64'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_decimals(uint64)uint64'] + }> + & Record<'verify_asset_params_get_default_frozen(uint64)bool' | 'verify_asset_params_get_default_frozen', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_default_frozen(uint64)bool'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_default_frozen(uint64)bool'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_default_frozen(uint64)bool'] + }> + & Record<'verify_asset_params_get_unit_name(uint64)byte[]' | 'verify_asset_params_get_unit_name', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_unit_name(uint64)byte[]'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_unit_name(uint64)byte[]'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_unit_name(uint64)byte[]'] + }> + & Record<'verify_asset_params_get_name(uint64)byte[]' | 'verify_asset_params_get_name', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_name(uint64)byte[]'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_name(uint64)byte[]'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_name(uint64)byte[]'] + }> + & Record<'verify_asset_params_get_url(uint64)byte[]' | 'verify_asset_params_get_url', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_url(uint64)byte[]'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_url(uint64)byte[]'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_url(uint64)byte[]'] + }> + & Record<'verify_asset_params_get_metadata_hash(uint64)byte[]' | 'verify_asset_params_get_metadata_hash', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_metadata_hash(uint64)byte[]'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_metadata_hash(uint64)byte[]'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_metadata_hash(uint64)byte[]'] + }> + & Record<'verify_asset_params_get_manager(uint64)address' | 'verify_asset_params_get_manager', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_manager(uint64)address'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_manager(uint64)address'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_manager(uint64)address'] + }> + & Record<'verify_asset_params_get_reserve(uint64)address' | 'verify_asset_params_get_reserve', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_reserve(uint64)address'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_reserve(uint64)address'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_reserve(uint64)address'] + }> + & Record<'verify_asset_params_get_freeze(uint64)address' | 'verify_asset_params_get_freeze', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_freeze(uint64)address'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_freeze(uint64)address'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_freeze(uint64)address'] + }> + & Record<'verify_asset_params_get_clawback(uint64)address' | 'verify_asset_params_get_clawback', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_clawback(uint64)address'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_clawback(uint64)address'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_clawback(uint64)address'] + }> + & Record<'verify_asset_params_get_creator(uint64)address' | 'verify_asset_params_get_creator', { + argsObj: StateAssetParamsContractArgs['obj']['verify_asset_params_get_creator(uint64)address'] + argsTuple: StateAssetParamsContractArgs['tuple']['verify_asset_params_get_creator(uint64)address'] + returns: StateAssetParamsContractReturns['verify_asset_params_get_creator(uint64)address'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type StateAssetParamsContractSignatures = keyof StateAssetParamsContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StateAssetParamsContractNonVoidMethodSignatures = keyof StateAssetParamsContractTypes['methods'] extends infer T ? T extends keyof StateAssetParamsContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateAssetParamsContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateAssetParamsContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateAssetParamsContract smart contract to the method's return type + */ +export type MethodReturn = StateAssetParamsContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateAssetParamsContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateAssetParamsContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateAssetParamsContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateAssetParamsContract smart contract + */ +export abstract class StateAssetParamsContractParamsFactory { + /** + * Constructs a no op call for the verify_asset_params_get_total(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetTotal(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_total(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_decimals(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetDecimals(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_decimals(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_default_frozen(uint64)bool ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetDefaultFrozen(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_default_frozen(uint64)bool' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_unit_name(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetUnitName(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_unit_name(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_name(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetName(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_name(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_url(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetUrl(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_url(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_metadata_hash(uint64)byte[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetMetadataHash(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_metadata_hash(uint64)byte[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_manager(uint64)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetManager(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_manager(uint64)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_reserve(uint64)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetReserve(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_reserve(uint64)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_freeze(uint64)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetFreeze(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_freeze(uint64)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_clawback(uint64)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetClawback(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_clawback(uint64)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } + /** + * Constructs a no op call for the verify_asset_params_get_creator(uint64)address ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verifyAssetParamsGetCreator(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify_asset_params_get_creator(uint64)address' as const, + args: Array.isArray(params.args) ? params.args : [params.args.a], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StateAssetParamsContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateAssetParamsContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateAssetParamsContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateAssetParamsContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateAssetParamsContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateAssetParamsContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateAssetParamsContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateAssetParamsContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAssetParamsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAssetParamsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateAssetParamsContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateAssetParamsContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateAssetParamsContract smart contract + */ +export class StateAssetParamsContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateAssetParamsContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StateAssetParamsContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateAssetParamsContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateAssetParamsContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateAssetParamsContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateAssetParamsContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateAssetParamsContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the StateAssetParamsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_total(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetTotal: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetTotal(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_decimals(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetDecimals: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetDecimals(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_default_frozen(uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetDefaultFrozen: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetDefaultFrozen(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_unit_name(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetUnitName: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetUnitName(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_name(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetName: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetName(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_url(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetUrl: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetUrl(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_metadata_hash(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetMetadataHash: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetMetadataHash(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_manager(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetManager: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetManager(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_reserve(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetReserve: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetReserve(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_freeze(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetFreeze: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetFreeze(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_clawback(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetClawback: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetClawback(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_creator(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verifyAssetParamsGetCreator: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetCreator(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the StateAssetParamsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_total(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetTotal: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetTotal(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_decimals(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetDecimals: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetDecimals(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_default_frozen(uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetDefaultFrozen: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetDefaultFrozen(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_unit_name(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetUnitName: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetUnitName(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_name(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetName: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetName(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_url(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetUrl: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetUrl(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_metadata_hash(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetMetadataHash: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetMetadataHash(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_manager(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetManager: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetManager(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_reserve(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetReserve: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetReserve(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_freeze(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetFreeze: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetFreeze(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_clawback(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetClawback: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetClawback(params)) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_creator(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verifyAssetParamsGetCreator: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetCreator(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the StateAssetParamsContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_total(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetTotal: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetTotal(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_total(uint64)uint64'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_decimals(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetDecimals: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetDecimals(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_decimals(uint64)uint64'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_default_frozen(uint64)bool` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetDefaultFrozen: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetDefaultFrozen(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_default_frozen(uint64)bool'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_unit_name(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetUnitName: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetUnitName(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_unit_name(uint64)byte[]'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_name(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetName: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetName(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_name(uint64)byte[]'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_url(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetUrl: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetUrl(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_url(uint64)byte[]'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_metadata_hash(uint64)byte[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetMetadataHash: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetMetadataHash(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_metadata_hash(uint64)byte[]'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_manager(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetManager: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetManager(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_manager(uint64)address'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_reserve(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetReserve: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetReserve(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_reserve(uint64)address'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_freeze(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetFreeze: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetFreeze(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_freeze(uint64)address'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_clawback(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetClawback: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetClawback(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_clawback(uint64)address'])} + }, + + /** + * Makes a call to the StateAssetParamsContract smart contract using the `verify_asset_params_get_creator(uint64)address` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verifyAssetParamsGetCreator: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StateAssetParamsContractParamsFactory.verifyAssetParamsGetCreator(params)) + return {...result, return: result.return as unknown as (undefined | StateAssetParamsContractReturns['verify_asset_params_get_creator(uint64)address'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateAssetParamsContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateAssetParamsContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateAssetParamsContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify_asset_params_get_total(uint64)uint64 method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetTotal(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetTotal(params))) + return this + }, + /** + * Add a verify_asset_params_get_decimals(uint64)uint64 method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetDecimals(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetDecimals(params))) + return this + }, + /** + * Add a verify_asset_params_get_default_frozen(uint64)bool method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetDefaultFrozen(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetDefaultFrozen(params))) + return this + }, + /** + * Add a verify_asset_params_get_unit_name(uint64)byte[] method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetUnitName(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetUnitName(params))) + return this + }, + /** + * Add a verify_asset_params_get_name(uint64)byte[] method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetName(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetName(params))) + return this + }, + /** + * Add a verify_asset_params_get_url(uint64)byte[] method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetUrl(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetUrl(params))) + return this + }, + /** + * Add a verify_asset_params_get_metadata_hash(uint64)byte[] method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetMetadataHash(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetMetadataHash(params))) + return this + }, + /** + * Add a verify_asset_params_get_manager(uint64)address method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetManager(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetManager(params))) + return this + }, + /** + * Add a verify_asset_params_get_reserve(uint64)address method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetReserve(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetReserve(params))) + return this + }, + /** + * Add a verify_asset_params_get_freeze(uint64)address method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetFreeze(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetFreeze(params))) + return this + }, + /** + * Add a verify_asset_params_get_clawback(uint64)address method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetClawback(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetClawback(params))) + return this + }, + /** + * Add a verify_asset_params_get_creator(uint64)address method call against the StateAssetParamsContract contract + */ + verifyAssetParamsGetCreator(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verifyAssetParamsGetCreator(params))) + return this + }, + /** + * Add a clear state call to the StateAssetParamsContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateAssetParamsContractComposer + } +} +export type StateAssetParamsContractComposer = { + /** + * Calls the verify_asset_params_get_total(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetTotal(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_total(uint64)uint64'] | undefined]> + + /** + * Calls the verify_asset_params_get_decimals(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetDecimals(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_decimals(uint64)uint64'] | undefined]> + + /** + * Calls the verify_asset_params_get_default_frozen(uint64)bool ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetDefaultFrozen(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_default_frozen(uint64)bool'] | undefined]> + + /** + * Calls the verify_asset_params_get_unit_name(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetUnitName(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_unit_name(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_asset_params_get_name(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetName(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_name(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_asset_params_get_url(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetUrl(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_url(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_asset_params_get_metadata_hash(uint64)byte[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetMetadataHash(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_metadata_hash(uint64)byte[]'] | undefined]> + + /** + * Calls the verify_asset_params_get_manager(uint64)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetManager(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_manager(uint64)address'] | undefined]> + + /** + * Calls the verify_asset_params_get_reserve(uint64)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetReserve(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_reserve(uint64)address'] | undefined]> + + /** + * Calls the verify_asset_params_get_freeze(uint64)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetFreeze(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_freeze(uint64)address'] | undefined]> + + /** + * Calls the verify_asset_params_get_clawback(uint64)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetClawback(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_clawback(uint64)address'] | undefined]> + + /** + * Calls the verify_asset_params_get_creator(uint64)address ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verifyAssetParamsGetCreator(params?: CallParams): StateAssetParamsContractComposer<[...TReturns, StateAssetParamsContractReturns['verify_asset_params_get_creator(uint64)address'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the StateAssetParamsContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateAssetParamsContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateAssetParamsContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateAssetParamsContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StateMutations.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StateMutations.ts new file mode 100644 index 0000000..01c58bc --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StateMutations.ts @@ -0,0 +1,880 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StateMutations","structs":{},"methods":[{"name":"append","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"modify","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"get","args":[],"returns":{"type":"(uint64,string)[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":3},"local":{"ints":0,"bytes":1}},"keys":{"global":{"no_proxy":{"keyType":"AVMString","valueType":"(uint64,string)[]","key":"bm9fcHJveHk="},"glob_assign":{"keyType":"AVMString","valueType":"(uint64,string)[]","key":"Z2xvYl9hc3NpZ24="},"glob":{"keyType":"AVMString","valueType":"(uint64,string)[]","key":"Z2xvYg=="}},"local":{"loc":{"keyType":"AVMString","valueType":"(uint64,string)[]","key":"bG9j"}},"box":{"box":{"keyType":"AVMString","valueType":"(uint64,string)[]","key":"Ym94"}}},"maps":{"global":{},"local":{},"box":{"map":{"keyType":"address","valueType":"(uint64,string)[]","prefix":"bWFw"}}}},"bareActions":{"create":["NoOp"],"call":["OptIn"]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[526,795,931],"errorMessage":"check self.box exists"},{"pc":[481,684,921],"errorMessage":"check self.glob exists"},{"pc":[440,577,916],"errorMessage":"check self.glob_assign exists"},{"pc":[506,742,928],"errorMessage":"check self.loc exists for account"},{"pc":[553,855,938],"errorMessage":"check self.map entry exists"},{"pc":[460,630,912],"errorMessage":"check self.no_proxy exists"},{"pc":[962],"errorMessage":"expected box == no_proxy"},{"pc":[950],"errorMessage":"expected global == no_proxy"},{"pc":[944],"errorMessage":"expected global assign == no_proxy"},{"pc":[956],"errorMessage":"expected local == no_proxy"},{"pc":[966],"errorMessage":"expected map == no_proxy"},{"pc":[593,619,646,672,700,726,758,784,811,837,871,897],"errorMessage":"index access is out of bounds"},{"pc":[585,638,692,750,803,863],"errorMessage":"invalid array length header"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock "box" "no_proxy" 0x0000 "glob_assign" "glob" "loc" 0x00020000000000000001000a000362617a 0x00086d6f646966696564 "map"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateMutations/statemutations.py:24
    // self.no_proxy = MyArray()
    bytec_1 // "no_proxy"
    bytec_2 // 0x0000
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@12
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x526e8bbf 0x95fef13d 0x0c29444b // method "append()void", method "modify()void", method "get()(uint64,string)[]"
    txna ApplicationArgs 0
    match append modify get
    err

main_bare_routing@12:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn OnCompletion
    switch main___algopy_default_create@13 main_opt_in@14
    err

main_opt_in@14:
    // tests/artifacts/StateMutations/statemutations.py:31
    // @arc4.baremethod(allow_actions=["OptIn"])
    txn ApplicationID
    assert
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_3 // "glob_assign"
    bytec_2 // 0x0000
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:34
    // self.glob.value = MyArray()
    bytec 4 // "glob"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:34
    // self.glob.value = MyArray()
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:35
    // self.box.value = MyArray()
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:35
    // self.box.value = MyArray()
    box_put
    // tests/artifacts/StateMutations/statemutations.py:36
    // self.loc[Txn.sender] = MyArray()
    txn Sender
    bytec 5 // "loc"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:36
    // self.loc[Txn.sender] = MyArray()
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:37
    // self.map[Txn.sender] = MyArray()
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_del
    pop
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:37
    // self.map[Txn.sender] = MyArray()
    box_put
    // tests/artifacts/StateMutations/statemutations.py:31
    // @arc4.baremethod(allow_actions=["OptIn"])
    intc_1 // 1
    return

main___algopy_default_create@13:
    txn ApplicationID
    !
    return


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    pushbytes ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_replace_dynamic_element(source: bytes, new_item: bytes, index: uint64) -> bytes:
dynamic_array_replace_dynamic_element:
    proto 3 1
    frame_dig -3
    substring 0 2
    dup
    btoi
    frame_dig -3
    extract 2 0
    frame_dig -1
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    frame_dig -1
    intc_1 // 1
    +
    intc_2 // 2
    *
    dig 2
    dig 1
    extract_uint16
    dig 3
    len
    dig 5
    frame_dig -1
    -
    intc_1 // 1
    -
    dig 1
    uncover 3
    uncover 2
    select
    dup
    dig 4
    -
    cover 6
    frame_dig -2
    len
    cover 6
    dig 4
    intc_0 // 0
    uncover 5
    substring3
    frame_dig -2
    concat
    uncover 4
    uncover 2
    uncover 3
    substring3
    concat
    cover 2
    swap
    intc_2 // 2
    *
    swap

dynamic_array_replace_dynamic_element_for_header@2:
    frame_dig 5
    frame_dig 4
    <
    bz dynamic_array_replace_dynamic_element_after_for@5
    frame_dig 3
    dup
    frame_dig 5
    dup
    cover 3
    extract_uint16
    frame_dig 2
    +
    frame_dig 1
    -
    itob
    extract 6 2
    dig 2
    swap
    replace3
    frame_bury 3
    intc_2 // 2
    +
    frame_bury 5
    b dynamic_array_replace_dynamic_element_for_header@2

dynamic_array_replace_dynamic_element_after_for@5:
    frame_dig 0
    frame_dig 3
    concat
    frame_bury 0
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.append[routing]() -> void:
append:
    // tests/artifacts/StateMutations/statemutations.py:42
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:45
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:46
    // self.no_proxy.append(struct.copy())
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:46
    // self.no_proxy.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:47
    // self.glob.value.append(struct.copy())
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:47
    // self.glob.value.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:48
    // self.loc[Txn.sender].append(struct.copy())
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:48
    // self.loc[Txn.sender].append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:49
    // self.box.value.append(struct.copy())
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:49
    // self.box.value.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:50
    // self.map[Txn.sender].append(struct.copy())
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:50
    // self.map[Txn.sender].append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    dig 1
    box_del
    pop
    box_put
    // tests/artifacts/StateMutations/statemutations.py:39
    // @arc4.abimethod
    intc_1 // 1
    return


// tests.artifacts.StateMutations.statemutations.StateMutations.modify[routing]() -> void:
modify:
    // tests/artifacts/StateMutations/statemutations.py:56
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:58
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    dig 1
    box_del
    pop
    box_put
    // tests/artifacts/StateMutations/statemutations.py:52
    // @arc4.abimethod
    intc_1 // 1
    return


// tests.artifacts.StateMutations.statemutations.StateMutations.get[routing]() -> void:
get:
    // tests/artifacts/StateMutations/statemutations.py:68
    // a0 = self.no_proxy.copy()
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    // tests/artifacts/StateMutations/statemutations.py:69
    // a1 = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:70
    // a2 = self.glob.value.copy()
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    // tests/artifacts/StateMutations/statemutations.py:71
    // a3 = self.loc[Txn.sender].copy()
    txn Sender
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    // tests/artifacts/StateMutations/statemutations.py:72
    // a4 = self.box.value.copy()
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    // tests/artifacts/StateMutations/statemutations.py:73
    // a5 = self.map[Txn.sender].copy()
    bytec 8 // "map"
    txn Sender
    concat
    box_get
    assert // check self.map entry exists
    // tests/artifacts/StateMutations/statemutations.py:75
    // assert a0 == a1, "expected global assign == no_proxy"
    dig 5
    uncover 5
    ==
    assert // expected global assign == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:76
    // assert a0 == a2, "expected global == no_proxy"
    dig 4
    uncover 4
    ==
    assert // expected global == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:77
    // assert a0 == a3, "expected local == no_proxy"
    dig 3
    uncover 3
    ==
    assert // expected local == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:78
    // assert a0 == a4, "expected box == no_proxy"
    dig 2
    uncover 2
    ==
    assert // expected box == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:79
    // assert a0 == a5, "expected map == no_proxy"
    dig 1
    ==
    assert // expected map == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:66
    // @arc4.abimethod
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyAEAAECCCYJA2JveAhub19wcm94eQIAAAtnbG9iX2Fzc2lnbgRnbG9iA2xvYxEAAgAAAAAAAAABAAoAA2JhegoACG1vZGlmaWVkA21hcDEYQAADKSpnMRtBACQxGRREMRhEggMEUm6LvwSV/vE9BAwpREs2GgCOAwE2Ab8DDgAxGY0CACMAAQAxGEQrKmcnBCpnKLxIKCq/MQAnBSpmJwgxAFBJvEgqvyNDMRgUQ4oEAYAASYv+JAuL/CQLIosEiwMMQQAci/2LBElOAlmLAggWVwYCiwFMUIwBJAiMBEL/3Iv9FYwAIowEiwSLAgxBAByL/4sESU4CWYsACBZXBgKLAUxQjAEkCIwEQv/ci/yL/ggWVwYCiwFQi/2LA4sAUlCL/xWL/4sCTwJSUIwAiYoDAYv9UQACSReL/VcCAIv/JAtLAUxZi/8jCCQLSwJLAVlLAxVLBYv/CSMJSwFPA08CTUlLBAlOBov+FU4GSwQiTwVSi/5QTwRPAk8DUlBOAkwkC0yLBYsEDEEAIIsDSYsFSU4DWYsCCIsBCRZXBgJLAkxdjAMkCIwFQv/YiwCLA1CMAIkiK2VESSJZTFcCACMnBoj+6StMZyIpZURJIllMVwIAIycGiP7VKUxnIicEZURJIllMVwIAIycGiP7AJwRMZzEASSInBWNESSJZTFcCACMnBoj+pycFTGYovkRJIllMVwIAIycGiP6TKLxIKEy/JwgxAFBJvkRJIllMVwIAIycGiP54SwG8SL8jQyIrZURJVwIASwEiWUsBIllLASMJSwMVSwQkWU8CTU8DTgJSSSVZIkxYJwdQTEQiiP7AK0xnIillRElXAgBLASJZSwEiWUsBIwlLAxVLBCRZTwJNTwNOAlJJJVkiTFgnB1BMRCKI/ospTGciJwRlRElXAgBLASJZSwEiWUsBIwlLAxVLBCRZTwJNTwNOAlJJJVkiTFgnB1BMRCKI/lUnBExnMQBJIicFY0RJVwIASwEiWUsBIllLASMJSwMVSwQkWU8CTU8DTgJSSSVZIkxYJwdQTEQiiP4bJwVMZii+RElXAgBLASJZSwEiWUsBIwlLAxVLBCRZTwJNTwNOAlJJJVkiTFgnB1BMRCKI/eYovEgoTL8nCDEAUEm+RElXAgBLASJZSwEiWUsBIwlLAxVLBCRZTwJNTwNOAlJJJVkiTFgnB1BMRCKI/apLAbxIvyNDIillRCIrZUQiJwRlRDEAIicFY0QovkQnCDEAUL5ESwVPBRJESwRPBBJESwNPAxJESwJPAhJESwESRIAEFR98dUxQsCND","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StateMutations contract + */ +export type StateMutationsArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'append()void': Record + 'modify()void': Record + 'get()(uint64,string)[]': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'append()void': [] + 'modify()void': [] + 'get()(uint64,string)[]': [] + } +} + +/** + * The return type for each method + */ +export type StateMutationsReturns = { + 'append()void': void + 'modify()void': void + 'get()(uint64,string)[]': [bigint, string][] +} + +/** + * Defines the types of available calls and state of the StateMutations smart contract. + */ +export type StateMutationsTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'append()void' | 'append', { + argsObj: StateMutationsArgs['obj']['append()void'] + argsTuple: StateMutationsArgs['tuple']['append()void'] + returns: StateMutationsReturns['append()void'] + }> + & Record<'modify()void' | 'modify', { + argsObj: StateMutationsArgs['obj']['modify()void'] + argsTuple: StateMutationsArgs['tuple']['modify()void'] + returns: StateMutationsReturns['modify()void'] + }> + & Record<'get()(uint64,string)[]' | 'get', { + argsObj: StateMutationsArgs['obj']['get()(uint64,string)[]'] + argsTuple: StateMutationsArgs['tuple']['get()(uint64,string)[]'] + returns: StateMutationsReturns['get()(uint64,string)[]'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + global: { + keys: { + noProxy: [bigint, string][] + globAssign: [bigint, string][] + glob: [bigint, string][] + } + maps: {} + } + local: { + keys: { + loc: [bigint, string][] + } + maps: {} + } + box: { + keys: { + box: [bigint, string][] + } + maps: { + map: Map + } + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type StateMutationsSignatures = keyof StateMutationsTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StateMutationsNonVoidMethodSignatures = keyof StateMutationsTypes['methods'] extends infer T ? T extends keyof StateMutationsTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StateMutations smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StateMutationsTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StateMutations smart contract to the method's return type + */ +export type MethodReturn = StateMutationsTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed global state of the application. + */ +export type GlobalKeysState = StateMutationsTypes['state']['global']['keys'] + +/** + * Defines the shape of the keyed local state of the application. + */ +export type LocalKeysState = StateMutationsTypes['state']['local']['keys'] + +/** + * Defines the shape of the keyed box state of the application. + */ +export type BoxKeysState = StateMutationsTypes['state']['box']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StateMutationsCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StateMutationsDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StateMutationsCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StateMutations smart contract + */ +export abstract class StateMutationsParamsFactory { + /** + * Constructs a no op call for the append()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static append(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'append()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the modify()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static modify(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'modify()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } + /** + * Constructs a no op call for the get()(uint64,string)[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static get(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'get()(uint64,string)[]' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StateMutations smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StateMutationsFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StateMutationsFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StateMutationsClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StateMutationsClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StateMutations smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StateMutationsDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StateMutationsClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateMutations smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateMutations smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StateMutations smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StateMutationsClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StateMutations smart contract + */ +export class StateMutationsClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StateMutationsClient` + * + * @param appClient An `AppClient` instance which has been created with the StateMutations app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StateMutationsClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StateMutationsClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StateMutationsClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StateMutationsClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StateMutationsClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateMutations smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The optIn result + */ + bare: (params?: Expand) => { + return this.appClient.params.bare.optIn(params) + }, + }, + + /** + * Makes a clear_state call to an existing instance of the StateMutations smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StateMutations smart contract using the `append()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + append: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(StateMutationsParamsFactory.append(params)) + }, + + /** + * Makes a call to the StateMutations smart contract using the `modify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + modify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(StateMutationsParamsFactory.modify(params)) + }, + + /** + * Makes a call to the StateMutations smart contract using the `get()(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + get: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(StateMutationsParamsFactory.get(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateMutations smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The optIn result + */ + bare: (params?: Expand) => { + return this.appClient.createTransaction.bare.optIn(params) + }, + }, + + /** + * Makes a clear_state call to an existing instance of the StateMutations smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StateMutations smart contract using the `append()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + append: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(StateMutationsParamsFactory.append(params)) + }, + + /** + * Makes a call to the StateMutations smart contract using the `modify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + modify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(StateMutationsParamsFactory.modify(params)) + }, + + /** + * Makes a call to the StateMutations smart contract using the `get()(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + get: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(StateMutationsParamsFactory.get(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available optIn methods + */ + optIn: { + /** + * Opts the user into an existing instance of the StateMutations smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The optIn result + */ + bare: (params?: Expand) => { + return this.appClient.send.bare.optIn(params) + }, + }, + + /** + * Makes a clear_state call to an existing instance of the StateMutations smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StateMutations smart contract using the `append()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + append: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(StateMutationsParamsFactory.append(params)) + return {...result, return: result.return as unknown as (undefined | StateMutationsReturns['append()void'])} + }, + + /** + * Makes a call to the StateMutations smart contract using the `modify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + modify: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(StateMutationsParamsFactory.modify(params)) + return {...result, return: result.return as unknown as (undefined | StateMutationsReturns['modify()void'])} + }, + + /** + * Makes a call to the StateMutations smart contract using the `get()(uint64,string)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + get: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(StateMutationsParamsFactory.get(params)) + return {...result, return: result.return as unknown as (undefined | StateMutationsReturns['get()(uint64,string)[]'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StateMutationsClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StateMutations app + */ + state = { + /** + * Methods to access global state for the current StateMutations app + */ + global: { + /** + * Get all current keyed values from global state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.global.getAll() + return { + noProxy: result.no_proxy, + globAssign: result.glob_assign, + glob: result.glob, + } + }, + /** + * Get the current value of the no_proxy key in global state + */ + noProxy: async (): Promise<[bigint, string][] | undefined> => { return (await this.appClient.state.global.getValue("no_proxy")) as [bigint, string][] | undefined }, + /** + * Get the current value of the glob_assign key in global state + */ + globAssign: async (): Promise<[bigint, string][] | undefined> => { return (await this.appClient.state.global.getValue("glob_assign")) as [bigint, string][] | undefined }, + /** + * Get the current value of the glob key in global state + */ + glob: async (): Promise<[bigint, string][] | undefined> => { return (await this.appClient.state.global.getValue("glob")) as [bigint, string][] | undefined }, + }, + /** + * Methods to access local state for the current StateMutations app + */ + local: (address: string | Address) => { + const encodedAddress = typeof address === 'string' ? address : encodeAddress(address.publicKey) + return { + /** + * Get all current keyed values from local state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.local(encodedAddress).getAll() + return { + loc: result.loc, + } + }, + /** + * Get the current value of the loc key in local state + */ + loc: async (): Promise<[bigint, string][] | undefined> => { return (await this.appClient.state.local(encodedAddress).getValue("loc")) as [bigint, string][] | undefined }, + } + }, + /** + * Methods to access box state for the current StateMutations app + */ + box: { + /** + * Get all current keyed values from box state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.box.getAll() + return { + box: result.box, + } + }, + /** + * Get the current value of the box key in box state + */ + box: async (): Promise<[bigint, string][] | undefined> => { return (await this.appClient.state.box.getValue("box")) as [bigint, string][] | undefined }, + /** + * Get values from the map map in box state + */ + map: { + /** + * Get all current values of the map map in box state + */ + getMap: async (): Promise> => { return (await this.appClient.state.box.getMap("map")) as Map }, + /** + * Get a current value of the map map by key from box state + */ + value: async (key: string): Promise<[bigint, string][] | undefined> => { return await this.appClient.state.box.getMapValue("map", key) as [bigint, string][] | undefined }, + }, + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): StateMutationsComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a append()void method call against the StateMutations contract + */ + append(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.append(params))) + return this + }, + /** + * Add a modify()void method call against the StateMutations contract + */ + modify(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.modify(params))) + return this + }, + /** + * Add a get()(uint64,string)[] method call against the StateMutations contract + */ + get(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.get(params))) + return this + }, + get optIn() { + return { + bare: (params?: AppClientBareCallParams ) => { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.optIn.bare(params))) + return this + }, + } + }, + /** + * Add a clear state call to the StateMutations contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StateMutationsComposer + } +} +export type StateMutationsComposer = { + /** + * Calls the append()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + append(params?: CallParams): StateMutationsComposer<[...TReturns, StateMutationsReturns['append()void'] | undefined]> + + /** + * Calls the modify()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + modify(params?: CallParams): StateMutationsComposer<[...TReturns, StateMutationsReturns['modify()void'] | undefined]> + + /** + * Calls the get()(uint64,string)[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + get(params?: CallParams): StateMutationsComposer<[...TReturns, StateMutationsReturns['get()(uint64,string)[]'] | undefined]> + + /** + * Gets available optIn methods + */ + readonly optIn: { + /** + * Opts the user into an existing instance of the StateMutations smart contract using a bare call. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + bare(params?: AppClientBareCallParams ): StateMutationsComposer + } + + /** + * Makes a clear_state call to an existing instance of the StateMutations smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StateMutationsComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StateMutationsComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StateMutationsComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/StaticSizeContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/StaticSizeContract.ts new file mode 100644 index 0000000..a0eb9be --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/StaticSizeContract.ts @@ -0,0 +1,1009 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"StaticSizeContract","structs":{},"methods":[{"name":"test_array","args":[{"type":"uint64","name":"x1"},{"type":"uint64","name":"y1"},{"type":"uint64","name":"x2"},{"type":"uint64","name":"y2"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_extend_from_tuple","args":[{"type":"((uint64,uint64),(uint64,uint64))","name":"some_more"}],"returns":{"type":"(uint64,uint64)[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_extend_from_arc4_tuple","args":[{"type":"((uint64,uint64),(uint64,uint64))","name":"some_more"}],"returns":{"type":"(uint64,uint64)[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_bool_array","args":[{"type":"uint64","name":"length"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_arc4_conversion","args":[{"type":"uint64","name":"length"}],"returns":{"type":"uint64[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"sum_array","args":[{"type":"uint64[]","name":"arc4_arr"}],"returns":{"type":"uint64"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}},{"name":"test_arc4_bool","args":[],"returns":{"type":"bool[]"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":1,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{"count":{"keyType":"AVMString","valueType":"AVMUint64","key":"Y291bnQ="}},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[1188,1205,1215],"errorMessage":"check self.count exists"},{"pc":[1033],"errorMessage":"expected 3 bytes"},{"pc":[750,761,861,1026,1115],"errorMessage":"expected correct length"},{"pc":[1053,1128],"errorMessage":"expected correct value at 0"},{"pc":[1073,1141],"errorMessage":"expected correct value at 1"},{"pc":[1154],"errorMessage":"expected correct value at 2"},{"pc":[1166],"errorMessage":"expected correct value at 3"},{"pc":[403,478,517,637,665,784,883,1035,1056,1117,1130,1143,1155],"errorMessage":"index access is out of bounds"},{"pc":[653,1018],"errorMessage":"invalid array length header"},{"pc":[729,753,840,908,999,1098],"errorMessage":"max array length exceeded"},{"pc":[283,342,377],"errorMessage":"overflow"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 8 16 144
    bytecblock 0x 0x151f7c75 "count" 0x00 0x0000
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/Arrays/static_size.py:39
    // self.count = UInt64(0)
    bytec_2 // "count"
    intc_0 // 0
    app_global_put

main_after_if_else@2:
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@16
    txn OnCompletion
    !
    assert
    txn ApplicationID
    assert
    pushbytess 0x28d7c1b8 0xfa9cb973 0x6039a240 0xf8fd68a7 0x1f028db1 0x096b3a59 0x8d6e3a25 // method "test_array(uint64,uint64,uint64,uint64)uint64", method "test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_bool_array(uint64)uint64", method "test_arc4_conversion(uint64)uint64[]", method "sum_array(uint64[])uint64", method "test_arc4_bool()bool[]"
    txna ApplicationArgs 0
    match test_array test_extend_from_tuple test_extend_from_arc4_tuple test_bool_array test_arc4_conversion sum_array test_arc4_bool
    err

main___algopy_default_create@16:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
dynamic_array_concat_bits:
    proto 4 1
    bytec_0 // ""
    dupn 2
    frame_dig -4
    intc_0 // 0
    extract_uint16
    dupn 2
    frame_dig -2
    +
    dup
    itob
    extract 6 0
    frame_dig -4
    swap
    replace2 0
    cover 2
    swap
    pushint 7
    +
    intc_2 // 8
    /
    dup
    uncover 2
    pushint 7
    +
    intc_2 // 8
    /
    dup
    cover 2
    <
    bz dynamic_array_concat_bits_after_if_else@2
    frame_dig 6
    frame_dig 5
    -
    bzero
    frame_dig 4
    swap
    concat
    frame_bury 4

dynamic_array_concat_bits_after_if_else@2:
    intc_0 // 0
    frame_bury 0
    frame_dig 3
    intc_3 // 16
    +
    dup
    frame_bury 2
    frame_dig -2
    +
    frame_bury 1

dynamic_array_concat_bits_while_top@3:
    frame_dig 2
    frame_dig 1
    <
    bz dynamic_array_concat_bits_after_while@5
    frame_dig -3
    frame_dig 0
    dup
    cover 2
    getbit
    frame_dig 4
    frame_dig 2
    dup
    cover 3
    uncover 2
    setbit
    frame_bury 4
    intc_1 // 1
    +
    frame_bury 2
    frame_dig -1
    +
    frame_bury 0
    b dynamic_array_concat_bits_while_top@3

dynamic_array_concat_bits_after_while@5:
    frame_dig 4
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_array[routing]() -> void:
test_array:
    intc_0 // 0
    dup
    bytec_0 // ""
    dupn 5
    // tests/artifacts/Arrays/static_size.py:41
    // @arc4.abimethod()
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/Arrays/static_size.py:43
    // self.count = UInt64(0)
    bytec_2 // "count"
    intc_0 // 0
    app_global_put
    // tests/artifacts/Arrays/static_size.py:46
    // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:47
    // Point(x=x1, y=y1, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:48
    // Point(x=x2, y=y2, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:44-50
    // path = ReferenceArray(
    //     (
    //         Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    //         Point(x=x1, y=y1, other=self.xtra()),
    //         Point(x=x2, y=y2, other=self.xtra()),
    //     )
    // )
    uncover 14
    itob
    uncover 14
    itob
    concat
    uncover 13
    concat
    uncover 12
    concat
    dig 11
    len
    pushint 64
    <=
    assert // overflow
    pushint 64
    bzero
    uncover 12
    dig 1
    b|
    uncover 2
    swap
    concat
    pushbytes 0x00000000000000000000000000000000
    swap
    concat
    uncover 14
    itob
    uncover 15
    swap
    concat
    uncover 12
    itob
    uncover 12
    itob
    concat
    uncover 11
    concat
    uncover 10
    concat
    dig 9
    len
    pushint 64
    <=
    assert // overflow
    uncover 9
    dig 4
    b|
    concat
    concat
    concat
    uncover 7
    itob
    uncover 8
    swap
    concat
    uncover 7
    itob
    uncover 7
    itob
    concat
    uncover 6
    concat
    uncover 5
    concat
    dig 4
    len
    pushint 64
    <=
    assert // overflow
    uncover 4
    uncover 4
    b|
    concat
    concat
    concat
    // tests/artifacts/Arrays/static_size.py:51
    // for i in urange(3):
    intc_0 // 0

test_array_for_header@2:
    // tests/artifacts/Arrays/static_size.py:51
    // for i in urange(3):
    dup
    pushint 3
    <
    bz test_array_after_for@5
    // tests/artifacts/Arrays/static_size.py:52
    // assert path[i].other.b == i + 1
    dup2
    dup
    cover 2
    intc 4 // 144
    *
    intc 4 // 144
    extract3 // on error: index access is out of bounds
    extract 16 128
    dup
    intc_2 // 8
    extract_uint64
    dig 2
    intc_1 // 1
    +
    swap
    dig 1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:53
    // assert path[i].other.d.foo == i + 2
    swap
    extract 48 16
    dup
    extract 0 8
    uncover 3
    pushint 2
    +
    itob
    b==
    assert
    // tests/artifacts/Arrays/static_size.py:54
    // assert path[i].other.d.bar == (i + 1) * (i + 1)
    extract 8 8
    dig 1
    dig 2
    *
    itob
    b==
    assert
    bury 1
    b test_array_for_header@2

test_array_after_for@5:
    dig 1
    // tests/artifacts/Arrays/static_size.py:56
    // Box(ImmutableArray[Point], key="a").value = path.freeze()
    dup
    len
    intc 4 // 144
    /
    dup
    bury 10
    itob
    extract 6 2
    dig 1
    concat
    pushbytes "a"
    box_del
    pop
    pushbytes "a"
    swap
    box_put
    // tests/artifacts/Arrays/static_size.py:168
    // last_point = path[0]
    extract 0 144 // on error: index access is out of bounds
    dup
    bury 11
    dup
    extract 0 8
    bury 10
    intc_2 // 8
    extract_uint64
    bury 6
    // tests/artifacts/Arrays/static_size.py:169
    // length = UInt64()
    intc_0 // 0
    bury 5
    // tests/artifacts/Arrays/static_size.py:170
    // for point_idx in urange(1, path.length):
    intc_1 // 1
    bury 3

test_array_for_header@7:
    // tests/artifacts/Arrays/static_size.py:170
    // for point_idx in urange(1, path.length):
    dig 2
    dig 8
    <
    bz test_array_after_for@15
    dig 1
    // tests/artifacts/Arrays/static_size.py:171
    // point = path[point_idx]
    dig 3
    intc 4 // 144
    *
    intc 4 // 144
    extract3 // on error: index access is out of bounds
    dupn 2
    extract 0 8
    swap
    intc_2 // 8
    extract_uint64
    bury 6
    // tests/artifacts/Arrays/static_size.py:172
    // if point.x < last_point.x:
    dig 10
    b<
    bz test_array_else_body@10
    // tests/artifacts/Arrays/static_size.py:173
    // dx = last_point.x.as_uint64() - point.x.as_uint64()
    dig 10
    // tests/artifacts/Arrays/static_size.py:168
    // last_point = path[0]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:173
    // dx = last_point.x.as_uint64() - point.x.as_uint64()
    extract_uint64
    swap
    // tests/artifacts/Arrays/static_size.py:171
    // point = path[point_idx]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:173
    // dx = last_point.x.as_uint64() - point.x.as_uint64()
    extract_uint64
    -
    bury 7

test_array_after_if_else@11:
    // tests/artifacts/Arrays/static_size.py:176
    // if point.y < last_point.y:
    dig 3
    dig 6
    <
    bz test_array_else_body@13
    // tests/artifacts/Arrays/static_size.py:177
    // dy = last_point.y - point.y
    dig 5
    dig 4
    -

test_array_after_if_else@14:
    // tests/artifacts/Arrays/static_size.py:180
    // length += op.sqrt(dx * dx + dy * dy)
    dig 7
    dup
    *
    swap
    dup
    *
    +
    sqrt
    dig 5
    +
    bury 5
    // tests/artifacts/Arrays/static_size.py:170
    // for point_idx in urange(1, path.length):
    dig 2
    intc_1 // 1
    +
    bury 3
    b test_array_for_header@7

test_array_else_body@13:
    // tests/artifacts/Arrays/static_size.py:179
    // dy = point.y - last_point.y
    dig 3
    dig 6
    -
    b test_array_after_if_else@14

test_array_else_body@10:
    // tests/artifacts/Arrays/static_size.py:171
    // point = path[point_idx]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:175
    // dx = point.x.as_uint64() - last_point.x.as_uint64()
    extract_uint64
    dig 10
    // tests/artifacts/Arrays/static_size.py:168
    // last_point = path[0]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:175
    // dx = point.x.as_uint64() - last_point.x.as_uint64()
    extract_uint64
    -
    bury 7
    b test_array_after_if_else@11

test_array_after_for@15:
    // tests/artifacts/Arrays/static_size.py:41
    // @arc4.abimethod()
    dig 4
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_tuple[routing]() -> void:
test_extend_from_tuple:
    // tests/artifacts/Arrays/static_size.py:59
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    extract 0 16
    swap
    extract 16 16
    // tests/artifacts/Arrays/static_size.py:62
    // arr.extend(some_more)
    swap
    dig 1
    concat
    // tests/artifacts/Arrays/static_size.py:63
    // last = arr[-1]
    dup
    len
    intc_3 // 16
    /
    dup
    intc_1 // 1
    -
    intc_3 // 16
    *
    dig 2
    swap
    intc_3 // 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/static_size.py:64
    // assert last == some_more[1]
    dup
    uncover 4
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:65
    // result = arr.freeze()
    swap
    itob
    extract 6 2
    uncover 2
    concat
    // tests/artifacts/Arrays/static_size.py:66
    // assert result[-1] == last
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 16
    *
    intc_3 // 16
    extract3 // on error: index access is out of bounds
    uncover 2
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:59
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_arc4_tuple[routing]() -> void:
test_extend_from_arc4_tuple:
    // tests/artifacts/Arrays/static_size.py:69
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:75
    // return arr.freeze()
    dup
    len
    intc_3 // 16
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/static_size.py:69
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_bool_array[routing]() -> void:
test_bool_array:
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/static_size.py:77
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    dup
    // tests/artifacts/Arrays/static_size.py:79
    // arr = ReferenceArray[bool]()
    bytec_0 // 0x
    swap
    // tests/artifacts/Arrays/static_size.py:82
    // for i in urange(1, length + 1):
    intc_1 // 1
    +
    intc_1 // 1

test_bool_array_for_header@2:
    // tests/artifacts/Arrays/static_size.py:82
    // for i in urange(1, length + 1):
    dup
    dig 2
    <
    bz test_bool_array_after_for@5
    // tests/artifacts/Arrays/static_size.py:83
    // arr.append(i % 2 == 0)
    dupn 2
    pushint 2
    %
    !
    dig 4
    swap
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat // on error: max array length exceeded
    bury 4
    // tests/artifacts/Arrays/static_size.py:82
    // for i in urange(1, length + 1):
    intc_1 // 1
    +
    bury 1
    b test_bool_array_for_header@2

test_bool_array_after_for@5:
    dig 2
    dupn 2
    // tests/artifacts/Arrays/static_size.py:84
    // assert arr.length == length, "expected correct length"
    len
    dig 6
    dup
    cover 4
    ==
    assert // expected correct length
    dig 1
    // tests/artifacts/Arrays/static_size.py:87
    // arr2.extend(arr)
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/static_size.py:88
    // assert arr2.length == length * 2, "expected correct length"
    len
    uncover 2
    pushint 2
    *
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:90
    // count = UInt64(0)
    intc_0 // 0
    bury 7
    // tests/artifacts/Arrays/static_size.py:91
    // for val in arr:
    len
    bury 7
    intc_0 // 0
    bury 5

test_bool_array_for_header@6:
    // tests/artifacts/Arrays/static_size.py:91
    // for val in arr:
    dig 4
    dig 7
    <
    bz test_bool_array_after_for@11
    dig 2
    dig 5
    intc_1 // 1
    extract3 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    // tests/artifacts/Arrays/static_size.py:92
    // if val:
    bz test_bool_array_after_if_else@9
    // tests/artifacts/Arrays/static_size.py:93
    // count += 1
    dig 5
    intc_1 // 1
    +
    bury 6

test_bool_array_after_if_else@9:
    dig 4
    intc_1 // 1
    +
    bury 5
    b test_bool_array_for_header@6

test_bool_array_after_for@11:
    // tests/artifacts/Arrays/static_size.py:77
    // @arc4.abimethod()
    dig 5
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_conversion[routing]() -> void:
test_arc4_conversion:
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/static_size.py:96
    // @arc4.abimethod()
    txna ApplicationArgs 1
    btoi
    dup
    // tests/artifacts/Arrays/static_size.py:98
    // arr = ReferenceArray[arc4.UInt64]()
    bytec_0 // 0x
    swap
    // tests/artifacts/Arrays/static_size.py:101
    // for i in urange(1, length + 1):
    intc_1 // 1
    +
    intc_1 // 1

test_arc4_conversion_for_header@2:
    // tests/artifacts/Arrays/static_size.py:101
    // for i in urange(1, length + 1):
    dup
    dig 2
    <
    bz test_arc4_conversion_after_for@5
    // tests/artifacts/Arrays/static_size.py:102
    // arr.append(arc4.UInt64(i))
    dupn 2
    itob
    dig 4
    swap
    concat // on error: max array length exceeded
    bury 4
    // tests/artifacts/Arrays/static_size.py:101
    // for i in urange(1, length + 1):
    intc_1 // 1
    +
    bury 1
    b test_arc4_conversion_for_header@2

test_arc4_conversion_after_for@5:
    dig 2
    // tests/artifacts/Arrays/static_size.py:103
    // assert arr.length == length, "expected correct length"
    len
    intc_2 // 8
    /
    dup
    bury 8
    dig 4
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:104
    // count = UInt64(0)
    intc_0 // 0
    bury 6
    intc_0 // 0
    bury 5

test_arc4_conversion_for_header@6:
    // tests/artifacts/Arrays/static_size.py:105
    // for val in arr:
    dig 4
    dig 7
    <
    bz test_arc4_conversion_after_for@11
    dig 2
    dig 5
    intc_2 // 8
    *
    intc_2 // 8
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/static_size.py:106
    // if val:
    bytec_0 // 0x
    b!=
    bz test_arc4_conversion_after_if_else@9
    // tests/artifacts/Arrays/static_size.py:107
    // count += 1
    dig 5
    intc_1 // 1
    +
    bury 6

test_arc4_conversion_after_if_else@9:
    dig 4
    intc_1 // 1
    +
    bury 5
    b test_arc4_conversion_for_header@6

test_arc4_conversion_after_for@11:
    // tests/artifacts/Arrays/static_size.py:109
    // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
    bytec 4 // 0x0000
    dig 3
    // tests/artifacts/Arrays/static_size.py:110
    // arc4_arr.extend(arr)
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    intc_2 // 8
    /
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/static_size.py:96
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.sum_array[routing]() -> void:
sum_array:
    // tests/artifacts/Arrays/static_size.py:114
    // @arc4.abimethod()
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:117
    // arr.extend(arc4_arr)
    extract 2 0
    dup
    // tests/artifacts/Arrays/static_size.py:119
    // total = UInt64(0)
    intc_0 // 0
    swap
    // tests/artifacts/Arrays/static_size.py:120
    // for item in arr:
    len
    intc_2 // 8
    /
    intc_0 // 0

sum_array_for_header@2:
    // tests/artifacts/Arrays/static_size.py:120
    // for item in arr:
    dup
    dig 2
    <
    bz sum_array_after_for@5
    dig 3
    dig 1
    dup
    cover 2
    intc_2 // 8
    *
    // tests/artifacts/Arrays/static_size.py:121
    // total += item.as_uint64()
    extract_uint64
    dig 4
    +
    bury 4
    intc_1 // 1
    +
    bury 1
    b sum_array_for_header@2

sum_array_after_for@5:
    // tests/artifacts/Arrays/static_size.py:114
    // @arc4.abimethod()
    dig 2
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_bool[routing]() -> void:
test_arc4_bool:
    // tests/artifacts/Arrays/static_size.py:142
    // arr.append(arc4.Bool(Txn.sender == Txn.receiver))
    txn Sender
    txn Receiver
    ==
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    // tests/artifacts/Arrays/static_size.py:143
    // arr.append(arc4.Bool(Txn.sender != Txn.receiver))
    txn Sender
    txn Receiver
    !=
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat // on error: max array length exceeded
    dupn 2
    // tests/artifacts/Arrays/static_size.py:146
    // dyn_arr.extend(arr)
    len
    // tests/artifacts/Arrays/static_size.py:145
    // dyn_arr = arc4.DynamicArray[arc4.Bool]()
    bytec 4 // 0x0000
    // tests/artifacts/Arrays/static_size.py:146
    // dyn_arr.extend(arr)
    dig 2
    uncover 2
    intc_2 // 8
    callsub dynamic_array_concat_bits
    dup
    cover 2
    // tests/artifacts/Arrays/static_size.py:147
    // assert dyn_arr.length == 2, "expected correct length"
    dup
    intc_0 // 0
    extract_uint16 // on error: invalid array length header
    dup
    cover 3
    dup
    pushint 2
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:148
    // assert dyn_arr.bytes.length == 3, "expected 3 bytes"
    dig 1
    len
    pushint 3
    ==
    assert // expected 3 bytes
    // tests/artifacts/Arrays/static_size.py:149
    // assert dyn_arr[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
    dup
    assert // index access is out of bounds
    dig 1
    intc_3 // 16
    getbit
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 0
    // tests/artifacts/Arrays/static_size.py:150
    // assert dyn_arr[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
    intc_1 // 1
    >
    assert // index access is out of bounds
    pushint 17
    getbit
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 1
    intc_0 // 0

test_arc4_bool_for_header@2:
    // tests/artifacts/Arrays/static_size.py:153-155
    // # note: not supported currently
    // # arr2.extend(dyn_array)
    // for b in dyn_arr:
    dup
    dig 3
    <
    bz test_arc4_bool_after_for@5
    dupn 2
    intc_3 // 16
    +
    dig 5
    swap
    getbit
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    dig 3
    // tests/artifacts/Arrays/static_size.py:156
    // arr2.append(b)
    swap
    concat // on error: max array length exceeded
    bury 3
    intc_1 // 1
    +
    bury 1
    b test_arc4_bool_for_header@2

test_arc4_bool_after_for@5:
    dig 1
    // tests/artifacts/Arrays/static_size.py:157
    // assert arr2.length == 4, "expected correct length"
    dup
    len
    pushint 4
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:158
    // assert arr2[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
    dup
    extract 0 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 0
    // tests/artifacts/Arrays/static_size.py:159
    // assert arr2[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
    dup
    extract 1 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 1
    // tests/artifacts/Arrays/static_size.py:160
    // assert arr2[2] == (Txn.sender == Txn.receiver), "expected correct value at 2"
    dup
    extract 2 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 2
    // tests/artifacts/Arrays/static_size.py:161
    // assert arr2[3] == (Txn.sender != Txn.receiver), "expected correct value at 3"
    extract 3 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 3
    dig 4
    // tests/artifacts/Arrays/static_size.py:163
    // return arr.freeze()
    dup
    len
    bytec 4 // 0x0000
    cover 2
    intc_2 // 8
    callsub dynamic_array_concat_bits
    // tests/artifacts/Arrays/static_size.py:139
    // @arc4.abimethod()
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.xtra() -> uint64, uint64, bytes, bytes, bytes:
xtra:
    // tests/artifacts/Arrays/static_size.py:126
    // self.count += 1
    intc_0 // 0
    bytec_2 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_1 // 1
    +
    bytec_2 // "count"
    dig 1
    app_global_put
    // tests/artifacts/Arrays/static_size.py:128
    // a=Txn.num_app_args,
    txn NumAppArgs
    // tests/artifacts/Arrays/static_size.py:130
    // c=Txn.sender,
    txn Sender
    // tests/artifacts/Arrays/static_size.py:131
    // d=self.more(),
    callsub more
    // tests/artifacts/Arrays/static_size.py:132
    // e=BigUInt(self.count),
    intc_0 // 0
    bytec_2 // "count"
    app_global_get_ex
    assert // check self.count exists
    itob
    // tests/artifacts/Arrays/static_size.py:127-133
    // return Xtra(
    //     a=Txn.num_app_args,
    //     b=self.count,
    //     c=Txn.sender,
    //     d=self.more(),
    //     e=BigUInt(self.count),
    // )
    uncover 3
    cover 4
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.more() -> bytes:
more:
    // tests/artifacts/Arrays/static_size.py:137
    // return More(foo=arc4.UInt64(self.count + 1), bar=arc4.UInt64(self.count * self.count))
    intc_0 // 0
    bytec_2 // "count"
    app_global_get_ex
    assert // check self.count exists
    dup
    intc_1 // 1
    +
    itob
    dig 1
    uncover 2
    *
    itob
    concat
    retsub
","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CyAFAAEIEJABJgUABBUffHUFY291bnQBAAIAADEYQAADKiJnMRtBAEAxGRREMRhEggcEKNfBuAT6nLlzBGA5okAE+P1opwQfAo2xBAlrOlkEjW46JTYaAI4HAIEB+QI8Ak8CxgM4A2sAMRkUMRgUEEOKBAEoRwKL/CJZRwKL/ghJFlcGAIv8TFwATgJMgQcIJApJTwKBBwgkCklOAgxBAAyLBosFCa+LBExQjAQijACLAyUISYwCi/4IjAGLAosBDEEAIIv9iwBJTgJTiwSLAklOA08CVIwEIwiMAov/CIwAQv/YiwSMAIkiSShHBTYaATYaAhc2GgM2GgQXKiJniAOfiAOciAOZTw4WTw4WUE8NUE8MUEsLFYFADkSBQK9PDEsBq08CTFCAEAAAAAAAAAAAAAAAAAAAAABMUE8OFk8PTFBPDBZPDBZQTwtQTwpQSwkVgUAORE8JSwSrUFBQTwcWTwhMUE8HFk8HFlBPBlBPBVBLBBWBQA5ETwRPBKtQUFAiSYEDDEEAOUpJTgIhBAshBFhXEIBJJFtLAiMITEsBEkRMVzAQSVcACE8DgQIIFqhEVwgISwFLAgsWqERFAUL/wEsBSRUhBApJRQoWVwYCSwFQgAFhvEiAAWFMv1cAkElFC0lXAAhFCiRbRQYiRQUjRQNLAksIDEEAXEsBSwMhBAshBFhHAlcACEwkW0UGSwqkQQA2SwoiW0wiWwlFB0sDSwYMQQAcSwVLBAlLB0kLTEkLCJJLBQhFBUsCIwhFA0L/sEsDSwYJQv/hIltLCiJbCUUHQv/ISwQWKUxQsCNDNhoBSVcAEExXEBBMSwFQSRUlCkkjCSULSwJMJVhJTwQSREwWVwYCTwJQSSJZIwlLAVcCAEwlCyVYTwISRClMULAjQzYaAUkVJQoWVwYCTFApTFCwI0MoRwI2GgEXSShMIwgjSUsCDEEAGEcCgQIYFEsETCsiTwJUUEUEIwhFAUL/4UsCRwIVSwZJTgQSREsBUBVPAoECCxJEIkUHFUUHIkUFSwRLBwxBABpLAksFI1giU0EABksFIwhFBksEIwhFBUL/3ksFFilMULAjQyhHAjYaARdJKEwjCCNJSwIMQQAQRwIWSwRMUEUEIwhFAUL/6UsCFSQKSUUISwQSRCJFBiJFBUsESwcMQQAcSwJLBSQLJFgoqUEABksFIwhFBksEIwhFBUL/3CcESwNQSVcCABUkChZXBgJcAClMULAjQzYaAVcCAEkiTBUkCiJJSwIMQQAWSwNLAUlOAiQLW0sECEUEIwhFAUL/40sCFilMULAjQzEAMQcSKyJPAlQxADEHEysiTwJUUEcCFScESwJPAiSI/HxJTgJJIllJTgNJgQISREsBFYEDEkRJREsBJVMrIk8CVCJTMQAxBxISRCMNRIERUysiTwJUIlMxADEHExJEIklLAwxBABpHAiUISwVMUysiTwJUSwNMUEUDIwhFAUL/30sBSRWBBBJESVcAASJTMQAxBxISRElXAQEiUzEAMQcTEkRJVwIBIlMxADEHEhJEVwMBIlMxADEHExJESwRJFScETgIkiPvWKUxQsCNDIiplRCMIKksBZzEbMQCIAAoiKmVEFk8DTgSJIiplREkjCBZLAU8CCxZQiQ==","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the StaticSizeContract contract + */ +export type StaticSizeContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'test_array(uint64,uint64,uint64,uint64)uint64': { + x1: bigint | number + y1: bigint | number + x2: bigint | number + y2: bigint | number + } + 'test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]': { + someMore: [[bigint | number, bigint | number], [bigint | number, bigint | number]] + } + 'test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]': { + someMore: [[bigint | number, bigint | number], [bigint | number, bigint | number]] + } + 'test_bool_array(uint64)uint64': { + length: bigint | number + } + 'test_arc4_conversion(uint64)uint64[]': { + length: bigint | number + } + 'sum_array(uint64[])uint64': { + arc4Arr: bigint[] | number[] + } + 'test_arc4_bool()bool[]': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'test_array(uint64,uint64,uint64,uint64)uint64': [x1: bigint | number, y1: bigint | number, x2: bigint | number, y2: bigint | number] + 'test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]': [someMore: [[bigint | number, bigint | number], [bigint | number, bigint | number]]] + 'test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]': [someMore: [[bigint | number, bigint | number], [bigint | number, bigint | number]]] + 'test_bool_array(uint64)uint64': [length: bigint | number] + 'test_arc4_conversion(uint64)uint64[]': [length: bigint | number] + 'sum_array(uint64[])uint64': [arc4Arr: bigint[] | number[]] + 'test_arc4_bool()bool[]': [] + } +} + +/** + * The return type for each method + */ +export type StaticSizeContractReturns = { + 'test_array(uint64,uint64,uint64,uint64)uint64': bigint + 'test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]': [bigint, bigint][] + 'test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]': [bigint, bigint][] + 'test_bool_array(uint64)uint64': bigint + 'test_arc4_conversion(uint64)uint64[]': bigint[] + 'sum_array(uint64[])uint64': bigint + 'test_arc4_bool()bool[]': boolean[] +} + +/** + * Defines the types of available calls and state of the StaticSizeContract smart contract. + */ +export type StaticSizeContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'test_array(uint64,uint64,uint64,uint64)uint64' | 'test_array', { + argsObj: StaticSizeContractArgs['obj']['test_array(uint64,uint64,uint64,uint64)uint64'] + argsTuple: StaticSizeContractArgs['tuple']['test_array(uint64,uint64,uint64,uint64)uint64'] + returns: StaticSizeContractReturns['test_array(uint64,uint64,uint64,uint64)uint64'] + }> + & Record<'test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]' | 'test_extend_from_tuple', { + argsObj: StaticSizeContractArgs['obj']['test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'] + argsTuple: StaticSizeContractArgs['tuple']['test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'] + returns: StaticSizeContractReturns['test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'] + }> + & Record<'test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]' | 'test_extend_from_arc4_tuple', { + argsObj: StaticSizeContractArgs['obj']['test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'] + argsTuple: StaticSizeContractArgs['tuple']['test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'] + returns: StaticSizeContractReturns['test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'] + }> + & Record<'test_bool_array(uint64)uint64' | 'test_bool_array', { + argsObj: StaticSizeContractArgs['obj']['test_bool_array(uint64)uint64'] + argsTuple: StaticSizeContractArgs['tuple']['test_bool_array(uint64)uint64'] + returns: StaticSizeContractReturns['test_bool_array(uint64)uint64'] + }> + & Record<'test_arc4_conversion(uint64)uint64[]' | 'test_arc4_conversion', { + argsObj: StaticSizeContractArgs['obj']['test_arc4_conversion(uint64)uint64[]'] + argsTuple: StaticSizeContractArgs['tuple']['test_arc4_conversion(uint64)uint64[]'] + returns: StaticSizeContractReturns['test_arc4_conversion(uint64)uint64[]'] + }> + & Record<'sum_array(uint64[])uint64' | 'sum_array', { + argsObj: StaticSizeContractArgs['obj']['sum_array(uint64[])uint64'] + argsTuple: StaticSizeContractArgs['tuple']['sum_array(uint64[])uint64'] + returns: StaticSizeContractReturns['sum_array(uint64[])uint64'] + }> + & Record<'test_arc4_bool()bool[]' | 'test_arc4_bool', { + argsObj: StaticSizeContractArgs['obj']['test_arc4_bool()bool[]'] + argsTuple: StaticSizeContractArgs['tuple']['test_arc4_bool()bool[]'] + returns: StaticSizeContractReturns['test_arc4_bool()bool[]'] + }> + /** + * Defines the shape of the state of the application. + */ + state: { + global: { + keys: { + count: bigint + } + maps: {} + } + } +} + +/** + * Defines the possible abi call signatures. + */ +export type StaticSizeContractSignatures = keyof StaticSizeContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type StaticSizeContractNonVoidMethodSignatures = keyof StaticSizeContractTypes['methods'] extends infer T ? T extends keyof StaticSizeContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the StaticSizeContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = StaticSizeContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the StaticSizeContract smart contract to the method's return type + */ +export type MethodReturn = StaticSizeContractTypes['methods'][TSignature]['returns'] + +/** + * Defines the shape of the keyed global state of the application. + */ +export type GlobalKeysState = StaticSizeContractTypes['state']['global']['keys'] + + +/** + * Defines supported create method params for this smart contract + */ +export type StaticSizeContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type StaticSizeContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: StaticSizeContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the StaticSizeContract smart contract + */ +export abstract class StaticSizeContractParamsFactory { + /** + * Constructs a no op call for the test_array(uint64,uint64,uint64,uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_array(uint64,uint64,uint64,uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.x1, params.args.y1, params.args.x2, params.args.y2], + } + } + /** + * Constructs a no op call for the test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testExtendFromTuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.someMore], + } + } + /** + * Constructs a no op call for the test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testExtendFromArc4Tuple(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.someMore], + } + } + /** + * Constructs a no op call for the test_bool_array(uint64)uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testBoolArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_bool_array(uint64)uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.length], + } + } + /** + * Constructs a no op call for the test_arc4_conversion(uint64)uint64[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testArc4Conversion(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_arc4_conversion(uint64)uint64[]' as const, + args: Array.isArray(params.args) ? params.args : [params.args.length], + } + } + /** + * Constructs a no op call for the sum_array(uint64[])uint64 ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static sumArray(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'sum_array(uint64[])uint64' as const, + args: Array.isArray(params.args) ? params.args : [params.args.arc4Arr], + } + } + /** + * Constructs a no op call for the test_arc4_bool()bool[] ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testArc4Bool(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_arc4_bool()bool[]' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the StaticSizeContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class StaticSizeContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `StaticSizeContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new StaticSizeContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new StaticSizeContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the StaticSizeContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: StaticSizeContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new StaticSizeContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StaticSizeContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StaticSizeContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the StaticSizeContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new StaticSizeContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the StaticSizeContract smart contract + */ +export class StaticSizeContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `StaticSizeContractClient` + * + * @param appClient An `AppClient` instance which has been created with the StaticSizeContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `StaticSizeContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `StaticSizeContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new StaticSizeContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `StaticSizeContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new StaticSizeContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the StaticSizeContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_array(uint64,uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StaticSizeContractParamsFactory.testArray(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testExtendFromTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StaticSizeContractParamsFactory.testExtendFromTuple(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testExtendFromArc4Tuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StaticSizeContractParamsFactory.testExtendFromArc4Tuple(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_bool_array(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testBoolArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StaticSizeContractParamsFactory.testBoolArray(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_arc4_conversion(uint64)uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testArc4Conversion: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StaticSizeContractParamsFactory.testArc4Conversion(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `sum_array(uint64[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + sumArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.params.call(StaticSizeContractParamsFactory.sumArray(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_arc4_bool()bool[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(StaticSizeContractParamsFactory.testArc4Bool(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the StaticSizeContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_array(uint64,uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StaticSizeContractParamsFactory.testArray(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testExtendFromTuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StaticSizeContractParamsFactory.testExtendFromTuple(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testExtendFromArc4Tuple: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StaticSizeContractParamsFactory.testExtendFromArc4Tuple(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_bool_array(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testBoolArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StaticSizeContractParamsFactory.testBoolArray(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_arc4_conversion(uint64)uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testArc4Conversion: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StaticSizeContractParamsFactory.testArc4Conversion(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `sum_array(uint64[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + sumArray: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) => { + return this.appClient.createTransaction.call(StaticSizeContractParamsFactory.sumArray(params)) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_arc4_bool()bool[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testArc4Bool: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(StaticSizeContractParamsFactory.testArc4Bool(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the StaticSizeContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_array(uint64,uint64,uint64,uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StaticSizeContractParamsFactory.testArray(params)) + return {...result, return: result.return as unknown as (undefined | StaticSizeContractReturns['test_array(uint64,uint64,uint64,uint64)uint64'])} + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testExtendFromTuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StaticSizeContractParamsFactory.testExtendFromTuple(params)) + return {...result, return: result.return as unknown as (undefined | StaticSizeContractReturns['test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'])} + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testExtendFromArc4Tuple: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StaticSizeContractParamsFactory.testExtendFromArc4Tuple(params)) + return {...result, return: result.return as unknown as (undefined | StaticSizeContractReturns['test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'])} + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_bool_array(uint64)uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testBoolArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StaticSizeContractParamsFactory.testBoolArray(params)) + return {...result, return: result.return as unknown as (undefined | StaticSizeContractReturns['test_bool_array(uint64)uint64'])} + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_arc4_conversion(uint64)uint64[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testArc4Conversion: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StaticSizeContractParamsFactory.testArc4Conversion(params)) + return {...result, return: result.return as unknown as (undefined | StaticSizeContractReturns['test_arc4_conversion(uint64)uint64[]'])} + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `sum_array(uint64[])uint64` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + sumArray: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp }) => { + const result = await this.appClient.send.call(StaticSizeContractParamsFactory.sumArray(params)) + return {...result, return: result.return as unknown as (undefined | StaticSizeContractReturns['sum_array(uint64[])uint64'])} + }, + + /** + * Makes a call to the StaticSizeContract smart contract using the `test_arc4_bool()bool[]` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testArc4Bool: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(StaticSizeContractParamsFactory.testArc4Bool(params)) + return {...result, return: result.return as unknown as (undefined | StaticSizeContractReturns['test_arc4_bool()bool[]'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new StaticSizeContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current StaticSizeContract app + */ + state = { + /** + * Methods to access global state for the current StaticSizeContract app + */ + global: { + /** + * Get all current keyed values from global state + */ + getAll: async (): Promise>> => { + const result = await this.appClient.state.global.getAll() + return { + count: result.count, + } + }, + /** + * Get the current value of the count key in global state + */ + count: async (): Promise => { return (await this.appClient.state.global.getValue("count")) as bigint | undefined }, + }, + } + + public newGroup(composerConfig?: TransactionComposerConfig): StaticSizeContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a test_array(uint64,uint64,uint64,uint64)uint64 method call against the StaticSizeContract contract + */ + testArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testArray(params))) + return this + }, + /** + * Add a test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[] method call against the StaticSizeContract contract + */ + testExtendFromTuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testExtendFromTuple(params))) + return this + }, + /** + * Add a test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[] method call against the StaticSizeContract contract + */ + testExtendFromArc4Tuple(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testExtendFromArc4Tuple(params))) + return this + }, + /** + * Add a test_bool_array(uint64)uint64 method call against the StaticSizeContract contract + */ + testBoolArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testBoolArray(params))) + return this + }, + /** + * Add a test_arc4_conversion(uint64)uint64[] method call against the StaticSizeContract contract + */ + testArc4Conversion(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testArc4Conversion(params))) + return this + }, + /** + * Add a sum_array(uint64[])uint64 method call against the StaticSizeContract contract + */ + sumArray(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.sumArray(params))) + return this + }, + /** + * Add a test_arc4_bool()bool[] method call against the StaticSizeContract contract + */ + testArc4Bool(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testArc4Bool(params))) + return this + }, + /** + * Add a clear state call to the StaticSizeContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as StaticSizeContractComposer + } +} +export type StaticSizeContractComposer = { + /** + * Calls the test_array(uint64,uint64,uint64,uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testArray(params?: CallParams): StaticSizeContractComposer<[...TReturns, StaticSizeContractReturns['test_array(uint64,uint64,uint64,uint64)uint64'] | undefined]> + + /** + * Calls the test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testExtendFromTuple(params?: CallParams): StaticSizeContractComposer<[...TReturns, StaticSizeContractReturns['test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'] | undefined]> + + /** + * Calls the test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testExtendFromArc4Tuple(params?: CallParams): StaticSizeContractComposer<[...TReturns, StaticSizeContractReturns['test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]'] | undefined]> + + /** + * Calls the test_bool_array(uint64)uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testBoolArray(params?: CallParams): StaticSizeContractComposer<[...TReturns, StaticSizeContractReturns['test_bool_array(uint64)uint64'] | undefined]> + + /** + * Calls the test_arc4_conversion(uint64)uint64[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testArc4Conversion(params?: CallParams): StaticSizeContractComposer<[...TReturns, StaticSizeContractReturns['test_arc4_conversion(uint64)uint64[]'] | undefined]> + + /** + * Calls the sum_array(uint64[])uint64 ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + sumArray(params?: CallParams): StaticSizeContractComposer<[...TReturns, StaticSizeContractReturns['sum_array(uint64[])uint64'] | undefined]> + + /** + * Calls the test_arc4_bool()bool[] ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testArc4Bool(params?: CallParams): StaticSizeContractComposer<[...TReturns, StaticSizeContractReturns['test_arc4_bool()bool[]'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the StaticSizeContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): StaticSizeContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): StaticSizeContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type StaticSizeContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/TuplesContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/TuplesContract.ts new file mode 100644 index 0000000..1e2fe54 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/TuplesContract.ts @@ -0,0 +1,558 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"TuplesContract","structs":{},"methods":[{"name":"test_tuple_with_primitive_type","args":[],"returns":{"type":"(uint64,bool)"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9UdXBsZXMvY29udHJhY3QucHk6OAogICAgLy8gY2xhc3MgVHVwbGVzQ29udHJhY3QoQVJDNENvbnRyYWN0LCBhdm1fdmVyc2lvbj0xMSk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9fX2FsZ29weV9kZWZhdWx0X2NyZWF0ZUA1CiAgICBwdXNoYnl0ZXMgMHg3MjI5ZDc5YSAvLyBtZXRob2QgInRlc3RfdHVwbGVfd2l0aF9wcmltaXRpdmVfdHlwZSgpKHVpbnQ2NCxib29sKSIKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDAKICAgIG1hdGNoIG1haW5fdGVzdF90dXBsZV93aXRoX3ByaW1pdGl2ZV90eXBlX3JvdXRlQDMKICAgIGVycgoKbWFpbl90ZXN0X3R1cGxlX3dpdGhfcHJpbWl0aXZlX3R5cGVfcm91dGVAMzoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9UdXBsZXMvY29udHJhY3QucHk6OQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICAmJgogICAgYXNzZXJ0CiAgICBwdXNoYnl0ZXMgMHgxNTFmN2M3NTAwMDAwMDAwMDAwMDAwMDA4MAogICAgbG9nCiAgICBwdXNoaW50IDEKICAgIHJldHVybgoKbWFpbl9fX2FsZ29weV9kZWZhdWx0X2NyZWF0ZUA1OgogICAgdHhuIE9uQ29tcGxldGlvbgogICAgIQogICAgdHhuIEFwcGxpY2F0aW9uSUQKICAgICEKICAgICYmCiAgICByZXR1cm4K","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CzEbQQAogARyKdeaNhoAjgEAAQAxGRQxGBBEgA0VH3x1AAAAAAAAAACAsIEBQzEZFDEYFBBD","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the TuplesContract contract + */ +export type TuplesContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'test_tuple_with_primitive_type()(uint64,bool)': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'test_tuple_with_primitive_type()(uint64,bool)': [] + } +} + +/** + * The return type for each method + */ +export type TuplesContractReturns = { + 'test_tuple_with_primitive_type()(uint64,bool)': [bigint, boolean] +} + +/** + * Defines the types of available calls and state of the TuplesContract smart contract. + */ +export type TuplesContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'test_tuple_with_primitive_type()(uint64,bool)' | 'test_tuple_with_primitive_type', { + argsObj: TuplesContractArgs['obj']['test_tuple_with_primitive_type()(uint64,bool)'] + argsTuple: TuplesContractArgs['tuple']['test_tuple_with_primitive_type()(uint64,bool)'] + returns: TuplesContractReturns['test_tuple_with_primitive_type()(uint64,bool)'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type TuplesContractSignatures = keyof TuplesContractTypes['methods'] +/** + * Defines the possible abi call signatures for methods that return a non-void value. + */ +export type TuplesContractNonVoidMethodSignatures = keyof TuplesContractTypes['methods'] extends infer T ? T extends keyof TuplesContractTypes['methods'] ? MethodReturn extends void ? never : T : never : never +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the TuplesContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = TuplesContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the TuplesContract smart contract to the method's return type + */ +export type MethodReturn = TuplesContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type TuplesContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type TuplesContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: TuplesContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the TuplesContract smart contract + */ +export abstract class TuplesContractParamsFactory { + /** + * Constructs a no op call for the test_tuple_with_primitive_type()(uint64,bool) ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static testTupleWithPrimitiveType(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'test_tuple_with_primitive_type()(uint64,bool)' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the TuplesContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class TuplesContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `TuplesContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new TuplesContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new TuplesContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the TuplesContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: TuplesContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new TuplesContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the TuplesContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the TuplesContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the TuplesContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new TuplesContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the TuplesContract smart contract + */ +export class TuplesContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `TuplesContractClient` + * + * @param appClient An `AppClient` instance which has been created with the TuplesContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `TuplesContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `TuplesContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new TuplesContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `TuplesContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new TuplesContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the TuplesContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the TuplesContract smart contract using the `test_tuple_with_primitive_type()(uint64,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + testTupleWithPrimitiveType: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(TuplesContractParamsFactory.testTupleWithPrimitiveType(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the TuplesContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the TuplesContract smart contract using the `test_tuple_with_primitive_type()(uint64,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + testTupleWithPrimitiveType: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(TuplesContractParamsFactory.testTupleWithPrimitiveType(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the TuplesContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the TuplesContract smart contract using the `test_tuple_with_primitive_type()(uint64,bool)` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + testTupleWithPrimitiveType: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(TuplesContractParamsFactory.testTupleWithPrimitiveType(params)) + return {...result, return: result.return as unknown as (undefined | TuplesContractReturns['test_tuple_with_primitive_type()(uint64,bool)'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new TuplesContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current TuplesContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): TuplesContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a test_tuple_with_primitive_type()(uint64,bool) method call against the TuplesContract contract + */ + testTupleWithPrimitiveType(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.testTupleWithPrimitiveType(params))) + return this + }, + /** + * Add a clear state call to the TuplesContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as TuplesContractComposer + } +} +export type TuplesContractComposer = { + /** + * Calls the test_tuple_with_primitive_type()(uint64,bool) ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + testTupleWithPrimitiveType(params?: CallParams): TuplesContractComposer<[...TReturns, TuplesContractReturns['test_tuple_with_primitive_type()(uint64,bool)'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the TuplesContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): TuplesContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): TuplesContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type TuplesContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/contracts/VerifierContract.ts b/examples/p-py/projects/p-py-frontend/src/contracts/VerifierContract.ts new file mode 100644 index 0000000..9633b90 --- /dev/null +++ b/examples/p-py/projects/p-py-frontend/src/contracts/VerifierContract.ts @@ -0,0 +1,554 @@ +/* eslint-disable */ +/** + * This file was automatically generated by @algorandfoundation/algokit-client-generator. + * DO NOT MODIFY IT BY HAND. + * requires: @algorandfoundation/algokit-utils: ^10 + */ +import { type AlgorandClient } from '@algorandfoundation/algokit-utils/types/algorand-client' +import { ABIReturn, ABIStructType, Arc56Contract, getStructValueFromTupleValue } from '@algorandfoundation/algokit-utils/abi' +import { OnApplicationComplete, TransactionSigner, Transaction } from '@algorandfoundation/algokit-utils/transact' +import { SimulateResponse } from '@algorandfoundation/algokit-utils/algod-client' +import { Address, encodeAddress } from '@algorandfoundation/algokit-utils' +import { AppClientMethodCallParams, AppClientCompilationParams, AppClientDeployParams, CallOnComplete, AppClient as _AppClient, AppClientParams, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, AppClientBareCallParams, CloneAppClientParams } from '@algorandfoundation/algokit-utils/types/app-client' +import { SendParams,SendTransactionComposerResults } from '@algorandfoundation/algokit-utils/types/transaction' +import { AppFactoryCreateMethodCallParams, AppFactoryAppClientParams, AppFactoryDeployParams, AppFactoryParams, AppFactory as _AppFactory, AppFactoryResolveAppClientByCreatorAndNameParams, CreateSchema } from '@algorandfoundation/algokit-utils/types/app-factory' +import { TransactionComposer, TransactionComposerConfig, SkipSignaturesSimulateOptions, RawSimulateOptions, SimulateOptions, AppMethodCallTransactionArgument } from '@algorandfoundation/algokit-utils/types/composer' + +export const APP_SPEC: Arc56Contract = {"name":"VerifierContract","structs":{},"methods":[{"name":"verify","args":[],"returns":{"type":"void"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[56],"errorMessage":"Txn must be pay"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CzEbQQAYgARlqa7MNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEMxFoEASUsCDEEAEEcCOBCBARJEgQEIRQFC/+mBAUM=","clear":"C4EBQw=="},"events":[],"templateVariables":{}} as unknown as Arc56Contract + +/** + * A state record containing binary data + */ +export interface BinaryState { + /** + * Gets the state value as a Uint8Array + */ + asByteArray(): Uint8Array | undefined + /** + * Gets the state value as a string + */ + asString(): string | undefined +} + +class BinaryStateValue implements BinaryState { + constructor(private value: Uint8Array | undefined) {} + + asByteArray(): Uint8Array | undefined { + return this.value + } + + asString(): string | undefined { + return this.value !== undefined ? Buffer.from(this.value).toString('utf-8') : undefined + } +} + +/** + * Expands types for IntelliSense so they are more human readable + * See https://stackoverflow.com/a/69288824 + */ +export type Expand = T extends (...args: infer A) => infer R + ? (...args: Expand) => Expand + : T extends infer O + ? { [K in keyof O]: O[K] } + : never + + +/** + * The argument types for the VerifierContract contract + */ +export type VerifierContractArgs = { + /** + * The object representation of the arguments for each method + */ + obj: { + 'verify()void': Record + } + /** + * The tuple representation of the arguments for each method + */ + tuple: { + 'verify()void': [] + } +} + +/** + * The return type for each method + */ +export type VerifierContractReturns = { + 'verify()void': void +} + +/** + * Defines the types of available calls and state of the VerifierContract smart contract. + */ +export type VerifierContractTypes = { + /** + * Maps method signatures / names to their argument and return types. + */ + methods: + & Record<'verify()void' | 'verify', { + argsObj: VerifierContractArgs['obj']['verify()void'] + argsTuple: VerifierContractArgs['tuple']['verify()void'] + returns: VerifierContractReturns['verify()void'] + }> +} + +/** + * Defines the possible abi call signatures. + */ +export type VerifierContractSignatures = keyof VerifierContractTypes['methods'] +/** + * Defines an object containing all relevant parameters for a single call to the contract. + */ +export type CallParams = Expand< + Omit & + { + /** The args for the ABI method call, either as an ordered array or an object */ + args: Expand + } +> +/** + * Maps a method signature from the VerifierContract smart contract to the method's arguments in either tuple or struct form + */ +export type MethodArgs = VerifierContractTypes['methods'][TSignature]['argsObj' | 'argsTuple'] +/** + * Maps a method signature from the VerifierContract smart contract to the method's return type + */ +export type MethodReturn = VerifierContractTypes['methods'][TSignature]['returns'] + + +/** + * Defines supported create method params for this smart contract + */ +export type VerifierContractCreateCallParams = + | Expand +/** + * Defines arguments required for the deploy method. + */ +export type VerifierContractDeployParams = Expand & { + /** + * Create transaction parameters to use if a create needs to be issued as part of deployment; use `method` to define ABI call (if available) or leave out for a bare call (if available) + */ + createParams?: VerifierContractCreateCallParams +}> + + +/** + * Exposes methods for constructing `AppClient` params objects for ABI calls to the VerifierContract smart contract + */ +export abstract class VerifierContractParamsFactory { + /** + * Constructs a no op call for the verify()void ABI method + * + * @param params Parameters for the call + * @returns An `AppClientMethodCallParams` object for the call + */ + static verify(params: CallParams & CallOnComplete): AppClientMethodCallParams & CallOnComplete { + return { + ...params, + method: 'verify()void' as const, + args: Array.isArray(params.args) ? params.args : [], + } + } +} + +/** + * A factory to create and deploy one or more instance of the VerifierContract smart contract and to create one or more app clients to interact with those (or other) app instances + */ +export class VerifierContractFactory { + /** + * The underlying `AppFactory` for when you want to have more flexibility + */ + public readonly appFactory: _AppFactory + + /** + * Creates a new instance of `VerifierContractFactory` + * + * @param params The parameters to initialise the app factory with + */ + constructor(params: Omit) { + this.appFactory = new _AppFactory({ + ...params, + appSpec: APP_SPEC, + }) + } + + /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */ + public get appName() { + return this.appFactory.appName + } + + /** The ARC-56 app spec being used */ + get appSpec() { + return APP_SPEC + } + + /** A reference to the underlying `AlgorandClient` this app factory is using. */ + public get algorand(): AlgorandClient { + return this.appFactory.algorand + } + + /** + * Returns a new `AppClient` client for an app instance of the given ID. + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public getAppClientById(params: AppFactoryAppClientParams) { + return new VerifierContractClient(this.appFactory.getAppClientById(params)) + } + + /** + * Returns a new `AppClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * + * Automatically populates appName, defaultSender and source maps from the factory + * if not specified in the params. + * @param params The parameters to create the app client + * @returns The `AppClient` + */ + public async getAppClientByCreatorAndName( + params: AppFactoryResolveAppClientByCreatorAndNameParams, + ) { + return new VerifierContractClient(await this.appFactory.getAppClientByCreatorAndName(params)) + } + + /** + * Idempotently deploys the VerifierContract smart contract. + * + * @param params The arguments for the contract calls and any additional parameters for the call + * @returns The deployment result + */ + public async deploy(params: VerifierContractDeployParams = {}) { + const result = await this.appFactory.deploy({ + ...params, + }) + return { result: result.result, appClient: new VerifierContractClient(result.appClient) } + } + + /** + * Get parameters to create transactions (create and deploy related calls) for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the VerifierContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The params for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.params.bare.create(params) + }, + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the VerifierContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The transaction for a create call + */ + bare: (params?: Expand) => { + return this.appFactory.createTransaction.bare.create(params) + }, + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Gets available create methods + */ + create: { + /** + * Creates a new instance of the VerifierContract smart contract using a bare call. + * + * @param params The params for the bare (raw) call + * @returns The create result + */ + bare: async (params?: Expand) => { + const result = await this.appFactory.send.bare.create(params) + return { result: result.result, appClient: new VerifierContractClient(result.appClient) } + }, + }, + + } + +} +/** + * A client to make calls to the VerifierContract smart contract + */ +export class VerifierContractClient { + /** + * The underlying `AppClient` for when you want to have more flexibility + */ + public readonly appClient: _AppClient + + /** + * Creates a new instance of `VerifierContractClient` + * + * @param appClient An `AppClient` instance which has been created with the VerifierContract app spec + */ + constructor(appClient: _AppClient) + /** + * Creates a new instance of `VerifierContractClient` + * + * @param params The parameters to initialise the app client with + */ + constructor(params: Omit) + constructor(appClientOrParams: _AppClient | Omit) { + this.appClient = appClientOrParams instanceof _AppClient ? appClientOrParams : new _AppClient({ + ...appClientOrParams, + appSpec: APP_SPEC, + }) + } + + /** + * Returns a new `VerifierContractClient` client, resolving the app by creator address and name + * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note). + * @param params The parameters to create the app client + */ + public static async fromCreatorAndName(params: Omit): Promise { + return new VerifierContractClient(await _AppClient.fromCreatorAndName({...params, appSpec: APP_SPEC})) + } + + /** + * Returns an `VerifierContractClient` instance for the current network based on + * pre-determined network-specific app IDs specified in the ARC-56 app spec. + * + * If no IDs are in the app spec or the network isn't recognised, an error is thrown. + * @param params The parameters to create the app client + */ + static async fromNetwork( + params: Omit + ): Promise { + return new VerifierContractClient(await _AppClient.fromNetwork({...params, appSpec: APP_SPEC})) + } + + /** The ID of the app instance this client is linked to. */ + public get appId() { + return this.appClient.appId + } + + /** The app address of the app instance this client is linked to. */ + public get appAddress() { + return this.appClient.appAddress + } + + /** The name of the app. */ + public get appName() { + return this.appClient.appName + } + + /** The ARC-56 app spec being used */ + public get appSpec() { + return this.appClient.appSpec + } + + /** A reference to the underlying `AlgorandClient` this app client is using. */ + public get algorand(): AlgorandClient { + return this.appClient.algorand + } + + /** + * Get parameters to create transactions for the current app. A good mental model for this is that these parameters represent a deferred transaction creation. + */ + readonly params = { + /** + * Makes a clear_state call to an existing instance of the VerifierContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.params.bare.clearState(params) + }, + + /** + * Makes a call to the VerifierContract smart contract using the `verify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call params + */ + verify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.params.call(VerifierContractParamsFactory.verify(params)) + }, + + } + + /** + * Create transactions for the current app + */ + readonly createTransaction = { + /** + * Makes a clear_state call to an existing instance of the VerifierContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.createTransaction.bare.clearState(params) + }, + + /** + * Makes a call to the VerifierContract smart contract using the `verify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call transaction + */ + verify: (params: CallParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + return this.appClient.createTransaction.call(VerifierContractParamsFactory.verify(params)) + }, + + } + + /** + * Send calls to the current app + */ + readonly send = { + /** + * Makes a clear_state call to an existing instance of the VerifierContract smart contract. + * + * @param params The params for the bare (raw) call + * @returns The clearState result + */ + clearState: (params?: Expand) => { + return this.appClient.send.bare.clearState(params) + }, + + /** + * Makes a call to the VerifierContract smart contract using the `verify()void` ABI method. + * + * @param params The params for the smart contract call + * @returns The call result + */ + verify: async (params: CallParams & SendParams & { onComplete?: OnApplicationComplete.NoOp } = {args: []}) => { + const result = await this.appClient.send.call(VerifierContractParamsFactory.verify(params)) + return {...result, return: result.return as unknown as (undefined | VerifierContractReturns['verify()void'])} + }, + + } + + /** + * Clone this app client with different params + * + * @param params The params to use for the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value. + * @returns A new app client with the altered params + */ + public clone(params: CloneAppClientParams) { + return new VerifierContractClient(this.appClient.clone(params)) + } + + /** + * Methods to access state for the current VerifierContract app + */ + state = { + } + + public newGroup(composerConfig?: TransactionComposerConfig): VerifierContractComposer { + const client = this + const composer = this.algorand.newGroup(composerConfig) + let promiseChain:Promise = Promise.resolve() + return { + /** + * Add a verify()void method call against the VerifierContract contract + */ + verify(params: CallParams & { onComplete?: OnApplicationComplete.NoOp }) { + promiseChain = promiseChain.then(async () => composer.addAppCallMethodCall(await client.params.verify(params))) + return this + }, + /** + * Add a clear state call to the VerifierContract contract + */ + clearState(params: AppClientBareCallParams) { + promiseChain = promiseChain.then(() => composer.addAppCall(client.params.clearState(params))) + return this + }, + addTransaction(txn: Transaction, signer?: TransactionSigner) { + promiseChain = promiseChain.then(() => composer.addTransaction(txn, signer)) + return this + }, + async composer() { + await promiseChain + return composer + }, + async simulate(options?: SimulateOptions) { + await promiseChain + const result = await (!options ? composer.simulate() : composer.simulate(options)) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + }, + async send(params?: SendParams) { + await promiseChain + const result = await composer.send(params) + return { + ...result, + returns: result.returns?.map(val => val.returnValue) + } + } + } as unknown as VerifierContractComposer + } +} +export type VerifierContractComposer = { + /** + * Calls the verify()void ABI method. + * + * @param params Any additional parameters for the call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + verify(params?: CallParams): VerifierContractComposer<[...TReturns, VerifierContractReturns['verify()void'] | undefined]> + + /** + * Makes a clear_state call to an existing instance of the VerifierContract smart contract. + * + * @param params Any additional parameters for the bare call + * @returns The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions + */ + clearState(params?: AppClientBareCallParams): VerifierContractComposer<[...TReturns, undefined]> + + /** + * Adds a transaction to the composer + * + * @param txn A transaction to add to the transaction group + * @param signer The optional signer to use when signing this transaction. + */ + addTransaction(txn: Transaction, signer?: TransactionSigner): VerifierContractComposer + /** + * Returns the underlying AtomicTransactionComposer instance + */ + composer(): Promise + /** + * Simulates the transaction group and returns the result + */ + simulate(): Promise & { simulateResponse: SimulateResponse }> + simulate(options: SkipSignaturesSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + simulate(options: RawSimulateOptions): Promise & { simulateResponse: SimulateResponse }> + /** + * Sends the transaction group to the network and returns the results + */ + send(params?: SendParams): Promise> +} +export type VerifierContractComposerResults = Expand + diff --git a/examples/p-py/projects/p-py-frontend/src/interfaces/network.ts b/examples/p-py/projects/p-py-frontend/src/interfaces/network.ts index a458edc..fdb97ae 100644 --- a/examples/p-py/projects/p-py-frontend/src/interfaces/network.ts +++ b/examples/p-py/projects/p-py-frontend/src/interfaces/network.ts @@ -1,5 +1,4 @@ -import { AlgoClientConfig } from '@algorandfoundation/algokit-utils/types/network-client' -import type { TokenHeader } from 'algosdk/dist/types/client/urlTokenBaseHTTPClient' +import { AlgoClientConfig } from '@algorandfoundation/algokit-utils/network-client' export interface AlgoViteClientConfig extends AlgoClientConfig { /** Base URL of the server e.g. http://localhost, https://testnet-api.algonode.cloud/, etc. */ @@ -7,7 +6,7 @@ export interface AlgoViteClientConfig extends AlgoClientConfig { /** The port to use e.g. 4001, 443, etc. */ port: string | number /** The token to use for API authentication (or undefined if none needed) - can be a string, or an object with the header key => value */ - token: string | TokenHeader + token: string /** String representing current Algorand Network type (testnet/mainnet and etc) */ network: string } @@ -18,7 +17,7 @@ export interface AlgoViteKMDConfig extends AlgoClientConfig { /** The port to use e.g. 4001, 443, etc. */ port: string | number /** The token to use for API authentication (or undefined if none needed) - can be a string, or an object with the header key => value */ - token: string | TokenHeader + token: string /** KMD wallet name */ wallet: string /** KMD wallet password */ diff --git a/examples/p-py/projects/p-py-frontend/tsconfig.json b/examples/p-py/projects/p-py-frontend/tsconfig.json index 5cde02a..855bfc3 100644 --- a/examples/p-py/projects/p-py-frontend/tsconfig.json +++ b/examples/p-py/projects/p-py-frontend/tsconfig.json @@ -1,7 +1,7 @@ { "compilerOptions": { "target": "ES2020" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */, - "module": "ES2022" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */, + "module": "ESNext" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */, "declaration": true /* Generates corresponding '.d.ts' file. */, "declarationMap": true /* Generates a sourcemap for each corresponding '.d.ts' file. */, "sourceMap": true /* Generates corresponding '.map' file. */, @@ -15,7 +15,7 @@ "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */, "allowJs": false, "allowSyntheticDefaultImports": true, - "moduleResolution": "Node", + "moduleResolution": "Bundler", "resolveJsonModule": true, "isolatedModules": true, "noEmit": true, diff --git a/examples/p-py/projects/p-py-frontend/tsconfig.node.json b/examples/p-py/projects/p-py-frontend/tsconfig.node.json index 9d31e2a..e32f207 100644 --- a/examples/p-py/projects/p-py-frontend/tsconfig.node.json +++ b/examples/p-py/projects/p-py-frontend/tsconfig.node.json @@ -1,8 +1,8 @@ { "compilerOptions": { "composite": true, - "module": "ESNext", - "moduleResolution": "Node", + "module": "NodeNext", + "moduleResolution": "NodeNext", "allowSyntheticDefaultImports": true }, "include": ["vite.config.ts"] diff --git a/examples/p-tls/projects/p-tls-contracts/contracts/clients/CalculatorClient.ts b/examples/p-tls/projects/p-tls-contracts/contracts/clients/CalculatorClient.ts index ef4d4eb..d3674b9 100644 --- a/examples/p-tls/projects/p-tls-contracts/contracts/clients/CalculatorClient.ts +++ b/examples/p-tls/projects/p-tls-contracts/contracts/clients/CalculatorClient.ts @@ -24,7 +24,7 @@ import { SendParams, SendSingleTransactionResult, SendAtomicTransactionComposerR import { Address, encodeAddress, modelsv2, OnApplicationComplete, Transaction, TransactionSigner } from 'algosdk' import SimulateResponse = modelsv2.SimulateResponse -export const APP_SPEC: Arc56Contract = {"name":"Calculator","desc":"","methods":[{"name":"doMath","desc":"A method that takes two numbers and does either addition or subtraction","args":[{"name":"a","type":"uint64","desc":"The first uint64"},{"name":"b","type":"uint64","desc":"The second uint64"},{"name":"operation","type":"string","desc":"The operation to perform. Can be either 'sum' or 'difference'"}],"returns":{"type":"uint64","desc":"The result of the operation"},"actions":{"create":[],"call":["NoOp"]}},{"name":"hello","desc":"A demonstration method used in the AlgoKit fullstack template.\nGreets the user by name.","args":[{"name":"name","type":"string","desc":"The name of the user to greet."}],"returns":{"type":"string","desc":"A greeting message to the user."},"actions":{"create":[],"call":["NoOp"]}},{"name":"createApplication","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]}}],"arcs":[4,56],"structs":{},"state":{"schema":{"global":{"bytes":0,"ints":0},"local":{"bytes":0,"ints":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"teal":1,"source":"contracts/Calculator.algo.ts:3","pc":[0]},{"teal":2,"source":"contracts/Calculator.algo.ts:3","pc":[1,2,3]},{"teal":3,"source":"contracts/Calculator.algo.ts:3","pc":[4,5,6,7,8,9,10]},{"teal":15,"source":"contracts/Calculator.algo.ts:3","pc":[11,12]},{"teal":16,"source":"contracts/Calculator.algo.ts:3","pc":[13]},{"teal":17,"source":"contracts/Calculator.algo.ts:3","pc":[14,15]},{"teal":18,"source":"contracts/Calculator.algo.ts:3","pc":[16]},{"teal":19,"source":"contracts/Calculator.algo.ts:3","pc":[17,18]},{"teal":20,"source":"contracts/Calculator.algo.ts:3","pc":[19]},{"teal":21,"source":"contracts/Calculator.algo.ts:3","pc":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]},{"teal":25,"source":"contracts/Calculator.algo.ts:3","errorMessage":"The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?","pc":[46]},{"teal":35,"source":"contracts/Calculator.algo.ts:11","pc":[47,48,49]},{"teal":39,"source":"contracts/Calculator.algo.ts:12","pc":[50,51]},{"teal":40,"source":"contracts/Calculator.algo.ts:12","pc":[52,53]},{"teal":41,"source":"contracts/Calculator.algo.ts:12","pc":[54]},{"teal":42,"source":"contracts/Calculator.algo.ts:11","pc":[55]},{"teal":52,"source":"contracts/Calculator.algo.ts:22","pc":[56,57,58]},{"teal":56,"source":"contracts/Calculator.algo.ts:23","pc":[59,60]},{"teal":57,"source":"contracts/Calculator.algo.ts:23","pc":[61,62]},{"teal":58,"source":"contracts/Calculator.algo.ts:23","pc":[63]},{"teal":59,"source":"contracts/Calculator.algo.ts:23","pc":[64,65,66]},{"teal":60,"source":"contracts/Calculator.algo.ts:23","pc":[67,68]},{"teal":61,"source":"contracts/Calculator.algo.ts:23","pc":[69,70]},{"teal":62,"source":"contracts/Calculator.algo.ts:23","pc":[71]},{"teal":63,"source":"contracts/Calculator.algo.ts:23","pc":[72,73,74]},{"teal":66,"source":"contracts/Calculator.algo.ts:23","pc":[75,76]},{"teal":67,"source":"contracts/Calculator.algo.ts:23","pc":[77,78]},{"teal":68,"source":"contracts/Calculator.algo.ts:23","pc":[79]},{"teal":71,"source":"contracts/Calculator.algo.ts:22","pc":[80]},{"teal":76,"source":"contracts/Calculator.algo.ts:35","pc":[81]},{"teal":79,"source":"contracts/Calculator.algo.ts:35","pc":[82,83,84]},{"teal":80,"source":"contracts/Calculator.algo.ts:35","pc":[85,86,87]},{"teal":83,"source":"contracts/Calculator.algo.ts:35","pc":[88,89,90]},{"teal":84,"source":"contracts/Calculator.algo.ts:35","pc":[91]},{"teal":87,"source":"contracts/Calculator.algo.ts:35","pc":[92,93,94]},{"teal":88,"source":"contracts/Calculator.algo.ts:35","pc":[95]},{"teal":91,"source":"contracts/Calculator.algo.ts:35","pc":[96,97,98]},{"teal":92,"source":"contracts/Calculator.algo.ts:35","pc":[99]},{"teal":93,"source":"contracts/Calculator.algo.ts:35","pc":[100]},{"teal":94,"source":"contracts/Calculator.algo.ts:35","pc":[101]},{"teal":95,"source":"contracts/Calculator.algo.ts:35","pc":[102]},{"teal":96,"source":"contracts/Calculator.algo.ts:35","pc":[103]},{"teal":108,"source":"contracts/Calculator.algo.ts:35","pc":[104,105,106]},{"teal":111,"source":"contracts/Calculator.algo.ts:35","pc":[107,108]},{"teal":116,"source":"contracts/Calculator.algo.ts:38","pc":[109,110]},{"teal":117,"source":"contracts/Calculator.algo.ts:38","pc":[111,112,113,114,115]},{"teal":118,"source":"contracts/Calculator.algo.ts:38","pc":[116]},{"teal":119,"source":"contracts/Calculator.algo.ts:38","pc":[117,118,119]},{"teal":124,"source":"contracts/Calculator.algo.ts:39","pc":[120,121]},{"teal":125,"source":"contracts/Calculator.algo.ts:39","pc":[122,123]},{"teal":126,"source":"contracts/Calculator.algo.ts:39","pc":[124,125,126]},{"teal":127,"source":"contracts/Calculator.algo.ts:39","pc":[127,128]},{"teal":128,"source":"contracts/Calculator.algo.ts:38","pc":[129,130,131]},{"teal":133,"source":"contracts/Calculator.algo.ts:40","pc":[132,133]},{"teal":134,"source":"contracts/Calculator.algo.ts:40","pc":[134,135,136,137,138,139,140,141,142,143,144,145]},{"teal":135,"source":"contracts/Calculator.algo.ts:40","pc":[146]},{"teal":136,"source":"contracts/Calculator.algo.ts:40","pc":[147,148,149]},{"teal":141,"source":"contracts/Calculator.algo.ts:41","pc":[150,151]},{"teal":142,"source":"contracts/Calculator.algo.ts:41","pc":[152,153]},{"teal":143,"source":"contracts/Calculator.algo.ts:41","pc":[154,155,156]},{"teal":144,"source":"contracts/Calculator.algo.ts:41","pc":[157,158]},{"teal":145,"source":"contracts/Calculator.algo.ts:40","pc":[159,160,161]},{"teal":149,"source":"contracts/Calculator.algo.ts:42","errorMessage":"Invalid operation","pc":[162]},{"teal":154,"source":"contracts/Calculator.algo.ts:44","pc":[163,164]},{"teal":157,"source":"contracts/Calculator.algo.ts:35","pc":[165,166]},{"teal":158,"source":"contracts/Calculator.algo.ts:35","pc":[167]},{"teal":163,"source":"contracts/Calculator.algo.ts:54","pc":[168]},{"teal":166,"source":"contracts/Calculator.algo.ts:54","pc":[169,170,171]},{"teal":167,"source":"contracts/Calculator.algo.ts:54","pc":[172,173,174]},{"teal":170,"source":"contracts/Calculator.algo.ts:54","pc":[175,176,177]},{"teal":171,"source":"contracts/Calculator.algo.ts:54","pc":[178]},{"teal":172,"source":"contracts/Calculator.algo.ts:54","pc":[179]},{"teal":173,"source":"contracts/Calculator.algo.ts:54","pc":[180]},{"teal":174,"source":"contracts/Calculator.algo.ts:54","pc":[181,182,183]},{"teal":175,"source":"contracts/Calculator.algo.ts:54","pc":[184]},{"teal":176,"source":"contracts/Calculator.algo.ts:54","pc":[185]},{"teal":177,"source":"contracts/Calculator.algo.ts:54","pc":[186]},{"teal":178,"source":"contracts/Calculator.algo.ts:54","pc":[187]},{"teal":179,"source":"contracts/Calculator.algo.ts:54","pc":[188]},{"teal":180,"source":"contracts/Calculator.algo.ts:54","pc":[189]},{"teal":190,"source":"contracts/Calculator.algo.ts:54","pc":[190,191,192]},{"teal":194,"source":"contracts/Calculator.algo.ts:55","pc":[193,194,195,196,197,198,199,200,201]},{"teal":195,"source":"contracts/Calculator.algo.ts:55","pc":[202,203]},{"teal":196,"source":"contracts/Calculator.algo.ts:55","pc":[204]},{"teal":197,"source":"contracts/Calculator.algo.ts:54","pc":[205]},{"teal":200,"source":"contracts/Calculator.algo.ts:3","pc":[206]},{"teal":201,"source":"contracts/Calculator.algo.ts:3","pc":[207]},{"teal":204,"source":"contracts/Calculator.algo.ts:3","pc":[208,209,210,211,212,213]},{"teal":205,"source":"contracts/Calculator.algo.ts:3","pc":[214,215,216]},{"teal":206,"source":"contracts/Calculator.algo.ts:3","pc":[217,218,219,220]},{"teal":209,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for create NoOp","pc":[221]},{"teal":212,"source":"contracts/Calculator.algo.ts:3","pc":[222,223,224,225,226,227]},{"teal":213,"source":"contracts/Calculator.algo.ts:3","pc":[228,229,230,231,232,233]},{"teal":214,"source":"contracts/Calculator.algo.ts:3","pc":[234,235,236]},{"teal":215,"source":"contracts/Calculator.algo.ts:3","pc":[237,238,239,240,241,242]},{"teal":218,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for call NoOp","pc":[243]}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEw"},"byteCode":{"approval":"CiABASYBBBUffHUxGBSBBgsxGQiNDACwAAAAAAAAAAAAAACiAAAAAAAAAAAAAACKAgGL/4v+CImKAgGL/4v+D0EACIv/i/4JQgAFi/6L/wmJKDYaA1cCADYaAhc2GgEXiAAFFlCwIkOKAwGAAIv9gANzdW0SQQAMi/6L/4j/sIwAQgAfi/2ACmRpZmZlcmVuY2USQQAMi/6L/4j/m4wAQgABAIsAjACJKDYaAVcCAIgADEkVFlcGAkxQULAiQ4oBAYAHSGVsbG8sIIv/UIkiQ4AEuER7NjYaAI4B//EAgAR2p+8zgAQCvs4RNhoAjgL/Xv+1AA==","clear":"Cg=="},"compilerInfo":{"compiler":"algod","compilerVersion":{"major":4,"minor":4,"patch":1,"commitHash":"7b607ce4"}}} as unknown as Arc56Contract +export const APP_SPEC: Arc56Contract = {"name":"Calculator","desc":"","methods":[{"name":"doMath","desc":"A method that takes two numbers and does either addition or subtraction","args":[{"name":"a","type":"uint64","desc":"The first uint64"},{"name":"b","type":"uint64","desc":"The second uint64"},{"name":"operation","type":"string","desc":"The operation to perform. Can be either 'sum' or 'difference'"}],"returns":{"type":"uint64","desc":"The result of the operation"},"actions":{"create":[],"call":["NoOp"]}},{"name":"hello","desc":"A demonstration method used in the AlgoKit fullstack template.\nGreets the user by name.","args":[{"name":"name","type":"string","desc":"The name of the user to greet."}],"returns":{"type":"string","desc":"A greeting message to the user."},"actions":{"create":[],"call":["NoOp"]}},{"name":"createApplication","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]}}],"arcs":[4,56],"structs":{},"state":{"schema":{"global":{"bytes":0,"ints":0},"local":{"bytes":0,"ints":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"teal":1,"source":"contracts/Calculator.algo.ts:3","pc":[0]},{"teal":2,"source":"contracts/Calculator.algo.ts:3","pc":[1,2,3]},{"teal":3,"source":"contracts/Calculator.algo.ts:3","pc":[4,5,6,7,8,9,10]},{"teal":15,"source":"contracts/Calculator.algo.ts:3","pc":[11,12]},{"teal":16,"source":"contracts/Calculator.algo.ts:3","pc":[13]},{"teal":17,"source":"contracts/Calculator.algo.ts:3","pc":[14,15]},{"teal":18,"source":"contracts/Calculator.algo.ts:3","pc":[16]},{"teal":19,"source":"contracts/Calculator.algo.ts:3","pc":[17,18]},{"teal":20,"source":"contracts/Calculator.algo.ts:3","pc":[19]},{"teal":21,"source":"contracts/Calculator.algo.ts:3","pc":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]},{"teal":25,"source":"contracts/Calculator.algo.ts:3","errorMessage":"The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?","pc":[46]},{"teal":35,"source":"contracts/Calculator.algo.ts:11","pc":[47,48,49]},{"teal":39,"source":"contracts/Calculator.algo.ts:12","pc":[50,51]},{"teal":40,"source":"contracts/Calculator.algo.ts:12","pc":[52,53]},{"teal":41,"source":"contracts/Calculator.algo.ts:12","pc":[54]},{"teal":42,"source":"contracts/Calculator.algo.ts:11","pc":[55]},{"teal":52,"source":"contracts/Calculator.algo.ts:22","pc":[56,57,58]},{"teal":56,"source":"contracts/Calculator.algo.ts:23","pc":[59,60]},{"teal":57,"source":"contracts/Calculator.algo.ts:23","pc":[61,62]},{"teal":58,"source":"contracts/Calculator.algo.ts:23","pc":[63]},{"teal":59,"source":"contracts/Calculator.algo.ts:23","pc":[64,65,66]},{"teal":60,"source":"contracts/Calculator.algo.ts:23","pc":[67,68]},{"teal":61,"source":"contracts/Calculator.algo.ts:23","pc":[69,70]},{"teal":62,"source":"contracts/Calculator.algo.ts:23","pc":[71]},{"teal":63,"source":"contracts/Calculator.algo.ts:23","pc":[72,73,74]},{"teal":66,"source":"contracts/Calculator.algo.ts:23","pc":[75,76]},{"teal":67,"source":"contracts/Calculator.algo.ts:23","pc":[77,78]},{"teal":68,"source":"contracts/Calculator.algo.ts:23","pc":[79]},{"teal":71,"source":"contracts/Calculator.algo.ts:22","pc":[80]},{"teal":76,"source":"contracts/Calculator.algo.ts:35","pc":[81]},{"teal":79,"source":"contracts/Calculator.algo.ts:35","pc":[82,83,84]},{"teal":80,"source":"contracts/Calculator.algo.ts:35","pc":[85,86,87]},{"teal":83,"source":"contracts/Calculator.algo.ts:35","pc":[88,89,90]},{"teal":84,"source":"contracts/Calculator.algo.ts:35","pc":[91]},{"teal":87,"source":"contracts/Calculator.algo.ts:35","pc":[92,93,94]},{"teal":88,"source":"contracts/Calculator.algo.ts:35","pc":[95]},{"teal":91,"source":"contracts/Calculator.algo.ts:35","pc":[96,97,98]},{"teal":92,"source":"contracts/Calculator.algo.ts:35","pc":[99]},{"teal":93,"source":"contracts/Calculator.algo.ts:35","pc":[100]},{"teal":94,"source":"contracts/Calculator.algo.ts:35","pc":[101]},{"teal":95,"source":"contracts/Calculator.algo.ts:35","pc":[102]},{"teal":96,"source":"contracts/Calculator.algo.ts:35","pc":[103]},{"teal":108,"source":"contracts/Calculator.algo.ts:35","pc":[104,105,106]},{"teal":111,"source":"contracts/Calculator.algo.ts:35","pc":[107,108]},{"teal":116,"source":"contracts/Calculator.algo.ts:38","pc":[109,110]},{"teal":117,"source":"contracts/Calculator.algo.ts:38","pc":[111,112,113,114,115]},{"teal":118,"source":"contracts/Calculator.algo.ts:38","pc":[116]},{"teal":119,"source":"contracts/Calculator.algo.ts:38","pc":[117,118,119]},{"teal":124,"source":"contracts/Calculator.algo.ts:39","pc":[120,121]},{"teal":125,"source":"contracts/Calculator.algo.ts:39","pc":[122,123]},{"teal":126,"source":"contracts/Calculator.algo.ts:39","pc":[124,125,126]},{"teal":127,"source":"contracts/Calculator.algo.ts:39","pc":[127,128]},{"teal":128,"source":"contracts/Calculator.algo.ts:38","pc":[129,130,131]},{"teal":133,"source":"contracts/Calculator.algo.ts:40","pc":[132,133]},{"teal":134,"source":"contracts/Calculator.algo.ts:40","pc":[134,135,136,137,138,139,140,141,142,143,144,145]},{"teal":135,"source":"contracts/Calculator.algo.ts:40","pc":[146]},{"teal":136,"source":"contracts/Calculator.algo.ts:40","pc":[147,148,149]},{"teal":141,"source":"contracts/Calculator.algo.ts:41","pc":[150,151]},{"teal":142,"source":"contracts/Calculator.algo.ts:41","pc":[152,153]},{"teal":143,"source":"contracts/Calculator.algo.ts:41","pc":[154,155,156]},{"teal":144,"source":"contracts/Calculator.algo.ts:41","pc":[157,158]},{"teal":145,"source":"contracts/Calculator.algo.ts:40","pc":[159,160,161]},{"teal":149,"source":"contracts/Calculator.algo.ts:42","errorMessage":"Invalid operation","pc":[162]},{"teal":154,"source":"contracts/Calculator.algo.ts:44","pc":[163,164]},{"teal":157,"source":"contracts/Calculator.algo.ts:35","pc":[165,166]},{"teal":158,"source":"contracts/Calculator.algo.ts:35","pc":[167]},{"teal":163,"source":"contracts/Calculator.algo.ts:54","pc":[168]},{"teal":166,"source":"contracts/Calculator.algo.ts:54","pc":[169,170,171]},{"teal":167,"source":"contracts/Calculator.algo.ts:54","pc":[172,173,174]},{"teal":170,"source":"contracts/Calculator.algo.ts:54","pc":[175,176,177]},{"teal":171,"source":"contracts/Calculator.algo.ts:54","pc":[178]},{"teal":172,"source":"contracts/Calculator.algo.ts:54","pc":[179]},{"teal":173,"source":"contracts/Calculator.algo.ts:54","pc":[180]},{"teal":174,"source":"contracts/Calculator.algo.ts:54","pc":[181,182,183]},{"teal":175,"source":"contracts/Calculator.algo.ts:54","pc":[184]},{"teal":176,"source":"contracts/Calculator.algo.ts:54","pc":[185]},{"teal":177,"source":"contracts/Calculator.algo.ts:54","pc":[186]},{"teal":178,"source":"contracts/Calculator.algo.ts:54","pc":[187]},{"teal":179,"source":"contracts/Calculator.algo.ts:54","pc":[188]},{"teal":180,"source":"contracts/Calculator.algo.ts:54","pc":[189]},{"teal":190,"source":"contracts/Calculator.algo.ts:54","pc":[190,191,192]},{"teal":194,"source":"contracts/Calculator.algo.ts:55","pc":[193,194,195,196,197,198,199,200,201]},{"teal":195,"source":"contracts/Calculator.algo.ts:55","pc":[202,203]},{"teal":196,"source":"contracts/Calculator.algo.ts:55","pc":[204]},{"teal":197,"source":"contracts/Calculator.algo.ts:54","pc":[205]},{"teal":200,"source":"contracts/Calculator.algo.ts:3","pc":[206]},{"teal":201,"source":"contracts/Calculator.algo.ts:3","pc":[207]},{"teal":204,"source":"contracts/Calculator.algo.ts:3","pc":[208,209,210,211,212,213]},{"teal":205,"source":"contracts/Calculator.algo.ts:3","pc":[214,215,216]},{"teal":206,"source":"contracts/Calculator.algo.ts:3","pc":[217,218,219,220]},{"teal":209,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for create NoOp","pc":[221]},{"teal":212,"source":"contracts/Calculator.algo.ts:3","pc":[222,223,224,225,226,227]},{"teal":213,"source":"contracts/Calculator.algo.ts:3","pc":[228,229,230,231,232,233]},{"teal":214,"source":"contracts/Calculator.algo.ts:3","pc":[234,235,236]},{"teal":215,"source":"contracts/Calculator.algo.ts:3","pc":[237,238,239,240,241,242]},{"teal":218,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for call NoOp","pc":[243]}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEw"},"byteCode":{"approval":"CiABASYBBBUffHUxGBSBBgsxGQiNDACwAAAAAAAAAAAAAACiAAAAAAAAAAAAAACKAgGL/4v+CImKAgGL/4v+D0EACIv/i/4JQgAFi/6L/wmJKDYaA1cCADYaAhc2GgEXiAAFFlCwIkOKAwGAAIv9gANzdW0SQQAMi/6L/4j/sIwAQgAfi/2ACmRpZmZlcmVuY2USQQAMi/6L/4j/m4wAQgABAIsAjACJKDYaAVcCAIgADEkVFlcGAkxQULAiQ4oBAYAHSGVsbG8sIIv/UIkiQ4AEuER7NjYaAI4B//EAgAR2p+8zgAQCvs4RNhoAjgL/Xv+1AA==","clear":"Cg=="},"compilerInfo":{"compiler":"algod","compilerVersion":{"major":4,"minor":4,"patch":1,"commitHash":"7b607ce4"}}} as unknown as Arc56Contract /** * A state record containing binary data diff --git a/examples/p-tls/projects/p-tls-frontend/src/components/AppCalls.tsx b/examples/p-tls/projects/p-tls-frontend/src/components/AppCalls.tsx index 8a37e8d..a03f337 100644 --- a/examples/p-tls/projects/p-tls-frontend/src/components/AppCalls.tsx +++ b/examples/p-tls/projects/p-tls-frontend/src/components/AppCalls.tsx @@ -4,6 +4,7 @@ import { useState } from 'react' import { CalculatorFactory } from '../contracts/Calculator' import { getAlgodConfigFromViteEnvironment, getIndexerConfigFromViteEnvironment } from '../utils/network/getAlgoClientConfigs' import { AlgorandClient } from '@algorandfoundation/algokit-utils' +import { encodeTransactionRaw } from '@algorandfoundation/algokit-utils/transact' interface AppCallsInterface { openModal: boolean @@ -14,7 +15,7 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { const [loading, setLoading] = useState(false) const [contractInput, setContractInput] = useState('') const { enqueueSnackbar } = useSnackbar() - const { transactionSigner, activeAddress } = useWallet() + const { signTransactions, activeAddress } = useWallet() const algodConfig = getAlgodConfigFromViteEnvironment() const indexerConfig = getIndexerConfigFromViteEnvironment() @@ -22,7 +23,11 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { algodConfig, indexerConfig, }) - algorand.setDefaultSigner(transactionSigner) + algorand.setDefaultSigner(async (txnGroup, indexesToSign) => { + const encoded = txnGroup.map((txn) => encodeTransactionRaw(txn)) + const signed = await signTransactions(encoded, indexesToSign) + return signed.filter((s): s is Uint8Array => s !== null) + }) const sendAppCall = async () => { setLoading(true) diff --git a/examples/p-tls/projects/p-tls-frontend/src/contracts/Calculator.ts b/examples/p-tls/projects/p-tls-frontend/src/contracts/Calculator.ts index cc4657a..01af943 100644 --- a/examples/p-tls/projects/p-tls-frontend/src/contracts/Calculator.ts +++ b/examples/p-tls/projects/p-tls-frontend/src/contracts/Calculator.ts @@ -24,7 +24,7 @@ import { SendParams, SendSingleTransactionResult, SendAtomicTransactionComposerR import { Address, encodeAddress, modelsv2, OnApplicationComplete, Transaction, TransactionSigner } from 'algosdk' import SimulateResponse = modelsv2.SimulateResponse -export const APP_SPEC: Arc56Contract = {"name":"Calculator","desc":"","methods":[{"name":"doMath","desc":"A method that takes two numbers and does either addition or subtraction","args":[{"name":"a","type":"uint64","desc":"The first uint64"},{"name":"b","type":"uint64","desc":"The second uint64"},{"name":"operation","type":"string","desc":"The operation to perform. Can be either 'sum' or 'difference'"}],"returns":{"type":"uint64","desc":"The result of the operation"},"actions":{"create":[],"call":["NoOp"]}},{"name":"hello","desc":"A demonstration method used in the AlgoKit fullstack template.\nGreets the user by name.","args":[{"name":"name","type":"string","desc":"The name of the user to greet."}],"returns":{"type":"string","desc":"A greeting message to the user."},"actions":{"create":[],"call":["NoOp"]}},{"name":"createApplication","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]}}],"arcs":[4,56],"structs":{},"state":{"schema":{"global":{"bytes":0,"ints":0},"local":{"bytes":0,"ints":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"teal":1,"source":"contracts/Calculator.algo.ts:3","pc":[0]},{"teal":2,"source":"contracts/Calculator.algo.ts:3","pc":[1,2,3]},{"teal":3,"source":"contracts/Calculator.algo.ts:3","pc":[4,5,6,7,8,9,10]},{"teal":15,"source":"contracts/Calculator.algo.ts:3","pc":[11,12]},{"teal":16,"source":"contracts/Calculator.algo.ts:3","pc":[13]},{"teal":17,"source":"contracts/Calculator.algo.ts:3","pc":[14,15]},{"teal":18,"source":"contracts/Calculator.algo.ts:3","pc":[16]},{"teal":19,"source":"contracts/Calculator.algo.ts:3","pc":[17,18]},{"teal":20,"source":"contracts/Calculator.algo.ts:3","pc":[19]},{"teal":21,"source":"contracts/Calculator.algo.ts:3","pc":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]},{"teal":25,"source":"contracts/Calculator.algo.ts:3","errorMessage":"The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?","pc":[46]},{"teal":35,"source":"contracts/Calculator.algo.ts:11","pc":[47,48,49]},{"teal":39,"source":"contracts/Calculator.algo.ts:12","pc":[50,51]},{"teal":40,"source":"contracts/Calculator.algo.ts:12","pc":[52,53]},{"teal":41,"source":"contracts/Calculator.algo.ts:12","pc":[54]},{"teal":42,"source":"contracts/Calculator.algo.ts:11","pc":[55]},{"teal":52,"source":"contracts/Calculator.algo.ts:22","pc":[56,57,58]},{"teal":56,"source":"contracts/Calculator.algo.ts:23","pc":[59,60]},{"teal":57,"source":"contracts/Calculator.algo.ts:23","pc":[61,62]},{"teal":58,"source":"contracts/Calculator.algo.ts:23","pc":[63]},{"teal":59,"source":"contracts/Calculator.algo.ts:23","pc":[64,65,66]},{"teal":60,"source":"contracts/Calculator.algo.ts:23","pc":[67,68]},{"teal":61,"source":"contracts/Calculator.algo.ts:23","pc":[69,70]},{"teal":62,"source":"contracts/Calculator.algo.ts:23","pc":[71]},{"teal":63,"source":"contracts/Calculator.algo.ts:23","pc":[72,73,74]},{"teal":66,"source":"contracts/Calculator.algo.ts:23","pc":[75,76]},{"teal":67,"source":"contracts/Calculator.algo.ts:23","pc":[77,78]},{"teal":68,"source":"contracts/Calculator.algo.ts:23","pc":[79]},{"teal":71,"source":"contracts/Calculator.algo.ts:22","pc":[80]},{"teal":76,"source":"contracts/Calculator.algo.ts:35","pc":[81]},{"teal":79,"source":"contracts/Calculator.algo.ts:35","pc":[82,83,84]},{"teal":80,"source":"contracts/Calculator.algo.ts:35","pc":[85,86,87]},{"teal":83,"source":"contracts/Calculator.algo.ts:35","pc":[88,89,90]},{"teal":84,"source":"contracts/Calculator.algo.ts:35","pc":[91]},{"teal":87,"source":"contracts/Calculator.algo.ts:35","pc":[92,93,94]},{"teal":88,"source":"contracts/Calculator.algo.ts:35","pc":[95]},{"teal":91,"source":"contracts/Calculator.algo.ts:35","pc":[96,97,98]},{"teal":92,"source":"contracts/Calculator.algo.ts:35","pc":[99]},{"teal":93,"source":"contracts/Calculator.algo.ts:35","pc":[100]},{"teal":94,"source":"contracts/Calculator.algo.ts:35","pc":[101]},{"teal":95,"source":"contracts/Calculator.algo.ts:35","pc":[102]},{"teal":96,"source":"contracts/Calculator.algo.ts:35","pc":[103]},{"teal":108,"source":"contracts/Calculator.algo.ts:35","pc":[104,105,106]},{"teal":111,"source":"contracts/Calculator.algo.ts:35","pc":[107,108]},{"teal":116,"source":"contracts/Calculator.algo.ts:38","pc":[109,110]},{"teal":117,"source":"contracts/Calculator.algo.ts:38","pc":[111,112,113,114,115]},{"teal":118,"source":"contracts/Calculator.algo.ts:38","pc":[116]},{"teal":119,"source":"contracts/Calculator.algo.ts:38","pc":[117,118,119]},{"teal":124,"source":"contracts/Calculator.algo.ts:39","pc":[120,121]},{"teal":125,"source":"contracts/Calculator.algo.ts:39","pc":[122,123]},{"teal":126,"source":"contracts/Calculator.algo.ts:39","pc":[124,125,126]},{"teal":127,"source":"contracts/Calculator.algo.ts:39","pc":[127,128]},{"teal":128,"source":"contracts/Calculator.algo.ts:38","pc":[129,130,131]},{"teal":133,"source":"contracts/Calculator.algo.ts:40","pc":[132,133]},{"teal":134,"source":"contracts/Calculator.algo.ts:40","pc":[134,135,136,137,138,139,140,141,142,143,144,145]},{"teal":135,"source":"contracts/Calculator.algo.ts:40","pc":[146]},{"teal":136,"source":"contracts/Calculator.algo.ts:40","pc":[147,148,149]},{"teal":141,"source":"contracts/Calculator.algo.ts:41","pc":[150,151]},{"teal":142,"source":"contracts/Calculator.algo.ts:41","pc":[152,153]},{"teal":143,"source":"contracts/Calculator.algo.ts:41","pc":[154,155,156]},{"teal":144,"source":"contracts/Calculator.algo.ts:41","pc":[157,158]},{"teal":145,"source":"contracts/Calculator.algo.ts:40","pc":[159,160,161]},{"teal":149,"source":"contracts/Calculator.algo.ts:42","errorMessage":"Invalid operation","pc":[162]},{"teal":154,"source":"contracts/Calculator.algo.ts:44","pc":[163,164]},{"teal":157,"source":"contracts/Calculator.algo.ts:35","pc":[165,166]},{"teal":158,"source":"contracts/Calculator.algo.ts:35","pc":[167]},{"teal":163,"source":"contracts/Calculator.algo.ts:54","pc":[168]},{"teal":166,"source":"contracts/Calculator.algo.ts:54","pc":[169,170,171]},{"teal":167,"source":"contracts/Calculator.algo.ts:54","pc":[172,173,174]},{"teal":170,"source":"contracts/Calculator.algo.ts:54","pc":[175,176,177]},{"teal":171,"source":"contracts/Calculator.algo.ts:54","pc":[178]},{"teal":172,"source":"contracts/Calculator.algo.ts:54","pc":[179]},{"teal":173,"source":"contracts/Calculator.algo.ts:54","pc":[180]},{"teal":174,"source":"contracts/Calculator.algo.ts:54","pc":[181,182,183]},{"teal":175,"source":"contracts/Calculator.algo.ts:54","pc":[184]},{"teal":176,"source":"contracts/Calculator.algo.ts:54","pc":[185]},{"teal":177,"source":"contracts/Calculator.algo.ts:54","pc":[186]},{"teal":178,"source":"contracts/Calculator.algo.ts:54","pc":[187]},{"teal":179,"source":"contracts/Calculator.algo.ts:54","pc":[188]},{"teal":180,"source":"contracts/Calculator.algo.ts:54","pc":[189]},{"teal":190,"source":"contracts/Calculator.algo.ts:54","pc":[190,191,192]},{"teal":194,"source":"contracts/Calculator.algo.ts:55","pc":[193,194,195,196,197,198,199,200,201]},{"teal":195,"source":"contracts/Calculator.algo.ts:55","pc":[202,203]},{"teal":196,"source":"contracts/Calculator.algo.ts:55","pc":[204]},{"teal":197,"source":"contracts/Calculator.algo.ts:54","pc":[205]},{"teal":200,"source":"contracts/Calculator.algo.ts:3","pc":[206]},{"teal":201,"source":"contracts/Calculator.algo.ts:3","pc":[207]},{"teal":204,"source":"contracts/Calculator.algo.ts:3","pc":[208,209,210,211,212,213]},{"teal":205,"source":"contracts/Calculator.algo.ts:3","pc":[214,215,216]},{"teal":206,"source":"contracts/Calculator.algo.ts:3","pc":[217,218,219,220]},{"teal":209,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for create NoOp","pc":[221]},{"teal":212,"source":"contracts/Calculator.algo.ts:3","pc":[222,223,224,225,226,227]},{"teal":213,"source":"contracts/Calculator.algo.ts:3","pc":[228,229,230,231,232,233]},{"teal":214,"source":"contracts/Calculator.algo.ts:3","pc":[234,235,236]},{"teal":215,"source":"contracts/Calculator.algo.ts:3","pc":[237,238,239,240,241,242]},{"teal":218,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for call NoOp","pc":[243]}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEw"},"byteCode":{"approval":"CiABASYBBBUffHUxGBSBBgsxGQiNDACwAAAAAAAAAAAAAACiAAAAAAAAAAAAAACKAgGL/4v+CImKAgGL/4v+D0EACIv/i/4JQgAFi/6L/wmJKDYaA1cCADYaAhc2GgEXiAAFFlCwIkOKAwGAAIv9gANzdW0SQQAMi/6L/4j/sIwAQgAfi/2ACmRpZmZlcmVuY2USQQAMi/6L/4j/m4wAQgABAIsAjACJKDYaAVcCAIgADEkVFlcGAkxQULAiQ4oBAYAHSGVsbG8sIIv/UIkiQ4AEuER7NjYaAI4B//EAgAR2p+8zgAQCvs4RNhoAjgL/Xv+1AA==","clear":"Cg=="},"compilerInfo":{"compiler":"algod","compilerVersion":{"major":4,"minor":4,"patch":1,"commitHash":"7b607ce4"}}} as unknown as Arc56Contract +export const APP_SPEC: Arc56Contract = {"name":"Calculator","desc":"","methods":[{"name":"doMath","desc":"A method that takes two numbers and does either addition or subtraction","args":[{"name":"a","type":"uint64","desc":"The first uint64"},{"name":"b","type":"uint64","desc":"The second uint64"},{"name":"operation","type":"string","desc":"The operation to perform. Can be either 'sum' or 'difference'"}],"returns":{"type":"uint64","desc":"The result of the operation"},"actions":{"create":[],"call":["NoOp"]}},{"name":"hello","desc":"A demonstration method used in the AlgoKit fullstack template.\nGreets the user by name.","args":[{"name":"name","type":"string","desc":"The name of the user to greet."}],"returns":{"type":"string","desc":"A greeting message to the user."},"actions":{"create":[],"call":["NoOp"]}},{"name":"createApplication","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]}}],"arcs":[4,56],"structs":{},"state":{"schema":{"global":{"bytes":0,"ints":0},"local":{"bytes":0,"ints":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"teal":1,"source":"contracts/Calculator.algo.ts:3","pc":[0]},{"teal":2,"source":"contracts/Calculator.algo.ts:3","pc":[1,2,3]},{"teal":3,"source":"contracts/Calculator.algo.ts:3","pc":[4,5,6,7,8,9,10]},{"teal":15,"source":"contracts/Calculator.algo.ts:3","pc":[11,12]},{"teal":16,"source":"contracts/Calculator.algo.ts:3","pc":[13]},{"teal":17,"source":"contracts/Calculator.algo.ts:3","pc":[14,15]},{"teal":18,"source":"contracts/Calculator.algo.ts:3","pc":[16]},{"teal":19,"source":"contracts/Calculator.algo.ts:3","pc":[17,18]},{"teal":20,"source":"contracts/Calculator.algo.ts:3","pc":[19]},{"teal":21,"source":"contracts/Calculator.algo.ts:3","pc":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]},{"teal":25,"source":"contracts/Calculator.algo.ts:3","errorMessage":"The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?","pc":[46]},{"teal":35,"source":"contracts/Calculator.algo.ts:11","pc":[47,48,49]},{"teal":39,"source":"contracts/Calculator.algo.ts:12","pc":[50,51]},{"teal":40,"source":"contracts/Calculator.algo.ts:12","pc":[52,53]},{"teal":41,"source":"contracts/Calculator.algo.ts:12","pc":[54]},{"teal":42,"source":"contracts/Calculator.algo.ts:11","pc":[55]},{"teal":52,"source":"contracts/Calculator.algo.ts:22","pc":[56,57,58]},{"teal":56,"source":"contracts/Calculator.algo.ts:23","pc":[59,60]},{"teal":57,"source":"contracts/Calculator.algo.ts:23","pc":[61,62]},{"teal":58,"source":"contracts/Calculator.algo.ts:23","pc":[63]},{"teal":59,"source":"contracts/Calculator.algo.ts:23","pc":[64,65,66]},{"teal":60,"source":"contracts/Calculator.algo.ts:23","pc":[67,68]},{"teal":61,"source":"contracts/Calculator.algo.ts:23","pc":[69,70]},{"teal":62,"source":"contracts/Calculator.algo.ts:23","pc":[71]},{"teal":63,"source":"contracts/Calculator.algo.ts:23","pc":[72,73,74]},{"teal":66,"source":"contracts/Calculator.algo.ts:23","pc":[75,76]},{"teal":67,"source":"contracts/Calculator.algo.ts:23","pc":[77,78]},{"teal":68,"source":"contracts/Calculator.algo.ts:23","pc":[79]},{"teal":71,"source":"contracts/Calculator.algo.ts:22","pc":[80]},{"teal":76,"source":"contracts/Calculator.algo.ts:35","pc":[81]},{"teal":79,"source":"contracts/Calculator.algo.ts:35","pc":[82,83,84]},{"teal":80,"source":"contracts/Calculator.algo.ts:35","pc":[85,86,87]},{"teal":83,"source":"contracts/Calculator.algo.ts:35","pc":[88,89,90]},{"teal":84,"source":"contracts/Calculator.algo.ts:35","pc":[91]},{"teal":87,"source":"contracts/Calculator.algo.ts:35","pc":[92,93,94]},{"teal":88,"source":"contracts/Calculator.algo.ts:35","pc":[95]},{"teal":91,"source":"contracts/Calculator.algo.ts:35","pc":[96,97,98]},{"teal":92,"source":"contracts/Calculator.algo.ts:35","pc":[99]},{"teal":93,"source":"contracts/Calculator.algo.ts:35","pc":[100]},{"teal":94,"source":"contracts/Calculator.algo.ts:35","pc":[101]},{"teal":95,"source":"contracts/Calculator.algo.ts:35","pc":[102]},{"teal":96,"source":"contracts/Calculator.algo.ts:35","pc":[103]},{"teal":108,"source":"contracts/Calculator.algo.ts:35","pc":[104,105,106]},{"teal":111,"source":"contracts/Calculator.algo.ts:35","pc":[107,108]},{"teal":116,"source":"contracts/Calculator.algo.ts:38","pc":[109,110]},{"teal":117,"source":"contracts/Calculator.algo.ts:38","pc":[111,112,113,114,115]},{"teal":118,"source":"contracts/Calculator.algo.ts:38","pc":[116]},{"teal":119,"source":"contracts/Calculator.algo.ts:38","pc":[117,118,119]},{"teal":124,"source":"contracts/Calculator.algo.ts:39","pc":[120,121]},{"teal":125,"source":"contracts/Calculator.algo.ts:39","pc":[122,123]},{"teal":126,"source":"contracts/Calculator.algo.ts:39","pc":[124,125,126]},{"teal":127,"source":"contracts/Calculator.algo.ts:39","pc":[127,128]},{"teal":128,"source":"contracts/Calculator.algo.ts:38","pc":[129,130,131]},{"teal":133,"source":"contracts/Calculator.algo.ts:40","pc":[132,133]},{"teal":134,"source":"contracts/Calculator.algo.ts:40","pc":[134,135,136,137,138,139,140,141,142,143,144,145]},{"teal":135,"source":"contracts/Calculator.algo.ts:40","pc":[146]},{"teal":136,"source":"contracts/Calculator.algo.ts:40","pc":[147,148,149]},{"teal":141,"source":"contracts/Calculator.algo.ts:41","pc":[150,151]},{"teal":142,"source":"contracts/Calculator.algo.ts:41","pc":[152,153]},{"teal":143,"source":"contracts/Calculator.algo.ts:41","pc":[154,155,156]},{"teal":144,"source":"contracts/Calculator.algo.ts:41","pc":[157,158]},{"teal":145,"source":"contracts/Calculator.algo.ts:40","pc":[159,160,161]},{"teal":149,"source":"contracts/Calculator.algo.ts:42","errorMessage":"Invalid operation","pc":[162]},{"teal":154,"source":"contracts/Calculator.algo.ts:44","pc":[163,164]},{"teal":157,"source":"contracts/Calculator.algo.ts:35","pc":[165,166]},{"teal":158,"source":"contracts/Calculator.algo.ts:35","pc":[167]},{"teal":163,"source":"contracts/Calculator.algo.ts:54","pc":[168]},{"teal":166,"source":"contracts/Calculator.algo.ts:54","pc":[169,170,171]},{"teal":167,"source":"contracts/Calculator.algo.ts:54","pc":[172,173,174]},{"teal":170,"source":"contracts/Calculator.algo.ts:54","pc":[175,176,177]},{"teal":171,"source":"contracts/Calculator.algo.ts:54","pc":[178]},{"teal":172,"source":"contracts/Calculator.algo.ts:54","pc":[179]},{"teal":173,"source":"contracts/Calculator.algo.ts:54","pc":[180]},{"teal":174,"source":"contracts/Calculator.algo.ts:54","pc":[181,182,183]},{"teal":175,"source":"contracts/Calculator.algo.ts:54","pc":[184]},{"teal":176,"source":"contracts/Calculator.algo.ts:54","pc":[185]},{"teal":177,"source":"contracts/Calculator.algo.ts:54","pc":[186]},{"teal":178,"source":"contracts/Calculator.algo.ts:54","pc":[187]},{"teal":179,"source":"contracts/Calculator.algo.ts:54","pc":[188]},{"teal":180,"source":"contracts/Calculator.algo.ts:54","pc":[189]},{"teal":190,"source":"contracts/Calculator.algo.ts:54","pc":[190,191,192]},{"teal":194,"source":"contracts/Calculator.algo.ts:55","pc":[193,194,195,196,197,198,199,200,201]},{"teal":195,"source":"contracts/Calculator.algo.ts:55","pc":[202,203]},{"teal":196,"source":"contracts/Calculator.algo.ts:55","pc":[204]},{"teal":197,"source":"contracts/Calculator.algo.ts:54","pc":[205]},{"teal":200,"source":"contracts/Calculator.algo.ts:3","pc":[206]},{"teal":201,"source":"contracts/Calculator.algo.ts:3","pc":[207]},{"teal":204,"source":"contracts/Calculator.algo.ts:3","pc":[208,209,210,211,212,213]},{"teal":205,"source":"contracts/Calculator.algo.ts:3","pc":[214,215,216]},{"teal":206,"source":"contracts/Calculator.algo.ts:3","pc":[217,218,219,220]},{"teal":209,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for create NoOp","pc":[221]},{"teal":212,"source":"contracts/Calculator.algo.ts:3","pc":[222,223,224,225,226,227]},{"teal":213,"source":"contracts/Calculator.algo.ts:3","pc":[228,229,230,231,232,233]},{"teal":214,"source":"contracts/Calculator.algo.ts:3","pc":[234,235,236]},{"teal":215,"source":"contracts/Calculator.algo.ts:3","pc":[237,238,239,240,241,242]},{"teal":218,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for call NoOp","pc":[243]}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEw"},"byteCode":{"approval":"CiABASYBBBUffHUxGBSBBgsxGQiNDACwAAAAAAAAAAAAAACiAAAAAAAAAAAAAACKAgGL/4v+CImKAgGL/4v+D0EACIv/i/4JQgAFi/6L/wmJKDYaA1cCADYaAhc2GgEXiAAFFlCwIkOKAwGAAIv9gANzdW0SQQAMi/6L/4j/sIwAQgAfi/2ACmRpZmZlcmVuY2USQQAMi/6L/4j/m4wAQgABAIsAjACJKDYaAVcCAIgADEkVFlcGAkxQULAiQ4oBAYAHSGVsbG8sIIv/UIkiQ4AEuER7NjYaAI4B//EAgAR2p+8zgAQCvs4RNhoAjgL/Xv+1AA==","clear":"Cg=="},"compilerInfo":{"compiler":"algod","compilerVersion":{"major":4,"minor":4,"patch":1,"commitHash":"7b607ce4"}}} as unknown as Arc56Contract /** * A state record containing binary data diff --git a/examples/p-ts/projects/p-ts-contracts/.algokit/.copier-answers.yml b/examples/p-ts/projects/p-ts-contracts/.algokit/.copier-answers.yml index 719485c..bec35c4 100644 --- a/examples/p-ts/projects/p-ts-contracts/.algokit/.copier-answers.yml +++ b/examples/p-ts/projects/p-ts-contracts/.algokit/.copier-answers.yml @@ -6,3 +6,4 @@ author_name: None contract_name: hello_world preset_name: production project_name: p-ts-contracts + diff --git a/examples/p-ts/projects/p-ts-contracts/.algokit/generators/create_contract/copier.yaml b/examples/p-ts/projects/p-ts-contracts/.algokit/generators/create_contract/copier.yaml index 67e3776..82f2c4a 100644 --- a/examples/p-ts/projects/p-ts-contracts/.algokit/generators/create_contract/copier.yaml +++ b/examples/p-ts/projects/p-ts-contracts/.algokit/generators/create_contract/copier.yaml @@ -4,12 +4,12 @@ _tasks: contract_name: type: str help: Name of your new contract. - placeholder: 'my-new-contract' - default: 'my-new-contract' + placeholder: "my-new-contract" + default: "my-new-contract" include_tests: type: bool help: Should we include testing files? default: 'yes' -_templates_suffix: '.j2' +_templates_suffix: ".j2" diff --git a/examples/p-ts/projects/p-ts-contracts/.algokit/generators/create_env_file/copier.yaml b/examples/p-ts/projects/p-ts-contracts/.algokit/generators/create_env_file/copier.yaml index dd81a7f..afa2cac 100644 --- a/examples/p-ts/projects/p-ts-contracts/.algokit/generators/create_env_file/copier.yaml +++ b/examples/p-ts/projects/p-ts-contracts/.algokit/generators/create_env_file/copier.yaml @@ -9,41 +9,41 @@ target_network: - testnet - localnet - custom - default: 'localnet' - when: '{{ not use_generic_env }}' + default: "localnet" + when: "{{ not use_generic_env }}" custom_network_name: type: str help: Name of your custom Algorand network. - placeholder: 'custom' + placeholder: "custom" when: "{{ not use_generic_env and target_network == 'custom' }}" is_localnet: type: bool help: Whether to deploy on localnet. - placeholder: 'true' + placeholder: "true" default: "{{ target_network == 'localnet' and not use_generic_env }}" when: 'false' is_testnet: type: bool help: Whether to deploy on testnet. - placeholder: 'true' + placeholder: "true" default: "{{ target_network == 'testnet' and not use_generic_env }}" when: 'false' is_mainnet: type: bool help: Whether to deploy on mainnet. - placeholder: 'true' + placeholder: "true" default: "{{ target_network == 'mainnet' and not use_generic_env }}" when: 'false' is_customnet: type: bool help: Whether to deploy on custom network. - placeholder: 'true' + placeholder: "true" default: "{{ target_network == 'custom' and not use_generic_env }}" when: 'false' -_templates_suffix: '.j2' +_templates_suffix: ".j2" diff --git a/examples/p-ts/projects/p-ts-contracts/.vscode/launch.json b/examples/p-ts/projects/p-ts-contracts/.vscode/launch.json index 002556d..093ebb1 100644 --- a/examples/p-ts/projects/p-ts-contracts/.vscode/launch.json +++ b/examples/p-ts/projects/p-ts-contracts/.vscode/launch.json @@ -45,8 +45,8 @@ "runtimeArgs": ["run", "build"], "cwd": "${workspaceFolder}", "console": "integratedTerminal", - "skipFiles": ["/**", "node_modules/**"] - }, + "skipFiles": ["/**", "node_modules/**"], + }, { "type": "avm", "request": "launch", diff --git a/examples/p-ts/projects/p-ts-contracts/.vscode/settings.json b/examples/p-ts/projects/p-ts-contracts/.vscode/settings.json index e2a31a2..b60a0a2 100644 --- a/examples/p-ts/projects/p-ts-contracts/.vscode/settings.json +++ b/examples/p-ts/projects/p-ts-contracts/.vscode/settings.json @@ -16,4 +16,4 @@ "extensions": [".ts"] }, "eslint.workingDirectories": ["./smart_contracts"] -} + } diff --git a/examples/p-ts/projects/p-ts-contracts/README.md b/examples/p-ts/projects/p-ts-contracts/README.md index 2282623..ae958d7 100644 --- a/examples/p-ts/projects/p-ts-contracts/README.md +++ b/examples/p-ts/projects/p-ts-contracts/README.md @@ -16,18 +16,15 @@ This project has been generated using AlgoKit. See below for default getting sta ### Initial Setup #### 1. Clone the Repository - Start by cloning this repository to your local machine. #### 2. Install Pre-requisites - Ensure the following pre-requisites are installed and properly configured: - **Docker**: Required for running a local Algorand network. - **AlgoKit CLI**: Essential for project setup and operations. Verify installation with `algokit --version`, expecting `2.6.0` or later. #### 3. Bootstrap Your Local Environment - Run the following commands within the project folder: - **Setup Project**: Execute `algokit project bootstrap all` to install dependencies and setup npm dependencies. @@ -37,16 +34,14 @@ Run the following commands within the project folder: ### Development Workflow #### Terminal - Directly manage and interact with your project using AlgoKit commands: 1. **Build Contracts**: `algokit project run build` compiles all smart contracts. You can also specify a specific contract by passing the name of the contract folder as an extra argument. - For example: `algokit project run build -- hello_world` will only build the `hello_world` contract. +For example: `algokit project run build -- hello_world` will only build the `hello_world` contract. 2. **Deploy**: Use `algokit project deploy localnet` to deploy contracts to the local network. You can also specify a specific contract by passing the name of the contract folder as an extra argument. - For example: `algokit project deploy localnet -- hello_world` will only deploy the `hello_world` contract. - -#### VS Code +For example: `algokit project deploy localnet -- hello_world` will only deploy the `hello_world` contract. +#### VS Code For a seamless experience with breakpoint debugging and other features: 1. **Open Project**: In VS Code, open the repository root. @@ -55,7 +50,6 @@ For a seamless experience with breakpoint debugging and other features: - Use `F5` to start debugging. #### JetBrains IDEs - While primarily optimized for VS Code, JetBrains IDEs are supported: 1. **Open Project**: In your JetBrains IDE, open the repository root. @@ -63,14 +57,13 @@ While primarily optimized for VS Code, JetBrains IDEs are supported: 3. **Debugging**: Use `Shift+F10` or `Ctrl+R` to start debugging. Note: Windows users may encounter issues with pre-launch tasks due to a known bug. See [JetBrains forums](https://youtrack.jetbrains.com/issue/IDEA-277486/Shell-script-configuration-cannot-run-as-before-launch-task) for workarounds. ## AlgoKit Workspaces and Project Management - This project supports both standalone and monorepo setups through AlgoKit workspaces. Leverage [`algokit project run`](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/project/run.md) commands for efficient monorepo project orchestration and management across multiple projects within a workspace. ## AlgoKit Generators This template provides a set of [algokit generators](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md) that allow you to further modify the project instantiated from the template to fit your needs, as well as giving you a base to build your own extensions to invoke via the `algokit generate` command. -### Generate Smart Contract +### Generate Smart Contract By default the template creates a single `HelloWorld` contract under hello_world folder in the `smart_contracts` directory. To add a new contract: @@ -82,7 +75,7 @@ By default the template creates a single `HelloWorld` contract under hello_world ### Generate '.env' files -By default the template instance does not contain any env files to deploy to different networks. Using [`algokit project deploy`](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/project/deploy.md) against `localnet` | `testnet` | `mainnet` will use default values for `algod` and `indexer` unless overwritten via `.env` or `.env.{target_network}`. +By default the template instance does not contain any env files to deploy to different networks. Using [`algokit project deploy`](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/project/deploy.md) against `localnet` | `testnet` | `mainnet` will use default values for `algod` and `indexer` unless overwritten via `.env` or `.env.{target_network}`. To generate a new `.env` or `.env.{target_network}` file, run `algokit generate env-file` @@ -92,6 +85,7 @@ This project is optimized to work with AlgoKit AVM Debugger extension. To activa Refer to the commented header in the `index.ts` file in the `smart_contracts` folder.Since you have opted in to include VSCode launch configurations in your project, you can also use the `Debug TEAL via AlgoKit AVM Debugger` launch configuration to interactively select an available trace file and launch the debug session for your smart contract. + For information on using and setting up the `AlgoKit AVM Debugger` VSCode extension refer [here](https://github.com/algorandfoundation/algokit-avm-vscode-debugger). To install the extension from the VSCode Marketplace, use the following link: [AlgoKit AVM Debugger extension](https://marketplace.visualstudio.com/items?itemName=algorandfoundation.algokit-avm-vscode-debugger).### Continuous Integration / Continuous Deployment (CI/CD) This project uses [GitHub Actions](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions) to define CI/CD workflows, which are located in the [.github/workflows](`../../.github/workflows`) folder. @@ -104,43 +98,41 @@ To define custom `algokit project run` commands refer to [documentation](https:/ #### Setting up GitHub for CI/CD workflow and TestNet deployment -1. Every time you have a change to your smart contract, and when you first initialize the project you need to [build the contract](#initial-setup) and then commit the `smart_contracts/artifacts` folder so the [output stability](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/articles/output_stability.md) tests pass -2. Decide what values you want to use for the `allowUpdate` and `allowDelete` parameters specified in [`deploy-config.ts`](./smart_contracts/hello_world/deploy-config.ts). - When deploying to LocalNet these values are both set to `true` for convenience. But for non-LocalNet networks - they are more conservative and use `false` - These default values will allow the smart contract to be deployed initially, but will not allow the app to be updated or deleted if is changed and the build will instead fail. - To help you decide it may be helpful to read the [AlgoKit Utils app deployment documentation](https://github.com/algorandfoundation/algokit-utils-ts/blob/main/docs/capabilities/app-deploy.md) or the [AlgoKit smart contract deployment architecture](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md#upgradeable-and-deletable-contracts). -3. Create a [Github Environment](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#creating-an-environment) named `Test`. - Note: If you have a private repository and don't have GitHub Enterprise then Environments won't work and you'll need to convert the GitHub Action to use a different approach. Ignore this step if you picked `Starter` preset. -4. Create or obtain a mnemonic for an Algorand account for use on TestNet to deploy apps, referred to as the `DEPLOYER` account. -5. Store the mnemonic as a [secret](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#environment-secrets) `DEPLOYER_MNEMONIC` - in the Test environment created in step 3. -6. The account used to deploy the smart contract will require enough funds to create the app, and also fund it. There are two approaches available here: - - Either, ensure the account is funded outside of CI/CD. - In Testnet, funds can be obtained by using the [Algorand TestNet dispenser](https://bank.testnet.algorand.network/) and we recommend provisioning 50 ALGOs. - - Or, fund the account as part of the CI/CD process by using a `DISPENSER_MNEMONIC` GitHub Environment secret to point to a separate `DISPENSER` account that you maintain ALGOs in (similarly, you need to provision ALGOs into this account using the [TestNet dispenser](https://bank.testnet.algorand.network/)). + 1. Every time you have a change to your smart contract, and when you first initialize the project you need to [build the contract](#initial-setup) and then commit the `smart_contracts/artifacts` folder so the [output stability](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/articles/output_stability.md) tests pass + 2. Decide what values you want to use for the `allowUpdate` and `allowDelete` parameters specified in [`deploy-config.ts`](./smart_contracts/hello_world/deploy-config.ts). + When deploying to LocalNet these values are both set to `true` for convenience. But for non-LocalNet networks + they are more conservative and use `false` + These default values will allow the smart contract to be deployed initially, but will not allow the app to be updated or deleted if is changed and the build will instead fail. + To help you decide it may be helpful to read the [AlgoKit Utils app deployment documentation](https://github.com/algorandfoundation/algokit-utils-ts/blob/main/docs/capabilities/app-deploy.md) or the [AlgoKit smart contract deployment architecture](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md#upgradeable-and-deletable-contracts). + 3. Create a [Github Environment](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#creating-an-environment) named `Test`. + Note: If you have a private repository and don't have GitHub Enterprise then Environments won't work and you'll need to convert the GitHub Action to use a different approach. Ignore this step if you picked `Starter` preset. + 4. Create or obtain a mnemonic for an Algorand account for use on TestNet to deploy apps, referred to as the `DEPLOYER` account. + 5. Store the mnemonic as a [secret](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#environment-secrets) `DEPLOYER_MNEMONIC` + in the Test environment created in step 3. + 6. The account used to deploy the smart contract will require enough funds to create the app, and also fund it. There are two approaches available here: + * Either, ensure the account is funded outside of CI/CD. + In Testnet, funds can be obtained by using the [Algorand TestNet dispenser](https://bank.testnet.algorand.network/) and we recommend provisioning 50 ALGOs. + * Or, fund the account as part of the CI/CD process by using a `DISPENSER_MNEMONIC` GitHub Environment secret to point to a separate `DISPENSER` account that you maintain ALGOs in (similarly, you need to provision ALGOs into this account using the [TestNet dispenser](https://bank.testnet.algorand.network/)). #### Continuous Integration For pull requests and pushes to `main` branch against this repository the following checks are automatically performed by GitHub Actions: - -- NPM dependencies are audited using [better-npm-audit](https://github.com/jeemok/better-npm-audit#readme) -- Code formatting is performed using [Prettier](https://prettier.io/) -- Linting is checked using [ESLint](https://eslint.org/) + - NPM dependencies are audited using [better-npm-audit](https://github.com/jeemok/better-npm-audit#readme) + - Code formatting is performed using [Prettier](https://prettier.io/) + - Linting is checked using [ESLint](https://eslint.org/) - The base framework for testing is [vitest](https://vitest.dev/), and the project includes two separate kinds of tests: - - `Algorand TypeScript` smart contract unit tests, that are run using [`algorand-typescript-testing`](https://github.com/algorandfoundation/algorand-typescript-testing), which are executed in a Node.js intepreter emulating major AVM behaviour - - End-to-end (e2e) `AppClient` tests that are run against `algokit localnet` and test the behaviour in a real network environment -- Smart contract artifacts are built -- Smart contract artifacts are checked for [output stability](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/articles/output_stability.md). -- Smart contract is deployed to a AlgoKit LocalNet instance + - Smart contract artifacts are built + - Smart contract artifacts are checked for [output stability](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/articles/output_stability.md). + - Smart contract is deployed to a AlgoKit LocalNet instance > NOTE: By default smart contract artifacts are compiled with `--debug-level` set to 0, to change this, modify the compiler invocation under the `build` script in `package.json` #### Continuous Deployment For pushes to `main` branch, after the above checks pass, the following deployment actions are performed: - -- The smart contract(s) are deployed to TestNet using [AlgoNode](https://algonode.io). + - The smart contract(s) are deployed to TestNet using [AlgoNode](https://algonode.io). > Please note deployment is also performed via `algokit deploy` command which can be invoked both via CI as seen on this project, or locally. For more information on how to use `algokit deploy` please see [AlgoKit documentation](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/deploy.md). @@ -158,4 +150,8 @@ This project makes use of Algorand TypeScript to build Algorand smart contracts. - [vitest](https://vitest.dev/): Automated testing. - [better-npm-audit](https://github.com/jeemok/better-npm-audit#readme): Tool for scanning JavaScript / TypeScript environments for packages with known vulnerabilities. + It has also been configured to have a productive dev experience out of the box in [VS Code](https://code.visualstudio.com/), see the [.vscode](./.vscode) folder. + + + diff --git a/examples/p-ts/projects/p-ts-contracts/eslint.config.mjs b/examples/p-ts/projects/p-ts-contracts/eslint.config.mjs index 17227c7..4d2428a 100644 --- a/examples/p-ts/projects/p-ts-contracts/eslint.config.mjs +++ b/examples/p-ts/projects/p-ts-contracts/eslint.config.mjs @@ -2,13 +2,17 @@ import eslint from '@eslint/js' import tseslint from 'typescript-eslint' import globals from 'globals' -export default tseslint.config(eslint.configs.recommended, tseslint.configs.recommended, { - languageOptions: { - globals: { - ...globals.node, +export default tseslint.config( + eslint.configs.recommended, + tseslint.configs.recommended, + { + languageOptions: { + globals: { + ...globals.node, + }, + }, + rules: { + '@typescript-eslint/explicit-member-accessibility': 'warn', }, }, - rules: { - '@typescript-eslint/explicit-member-accessibility': 'warn', - }, -}) +); diff --git a/examples/p-ts/projects/p-ts-contracts/smart_contracts/hello_world/deploy-config.ts b/examples/p-ts/projects/p-ts-contracts/smart_contracts/hello_world/deploy-config.ts index 6cf7f14..6b9d652 100644 --- a/examples/p-ts/projects/p-ts-contracts/smart_contracts/hello_world/deploy-config.ts +++ b/examples/p-ts/projects/p-ts-contracts/smart_contracts/hello_world/deploy-config.ts @@ -23,7 +23,7 @@ export async function deploy() { }) } - const method = 'hello' + const method = 'hello' const response = await appClient.send.hello({ args: { name: 'world' }, }) diff --git a/examples/p-ts/projects/p-ts-contracts/smart_contracts/index.ts b/examples/p-ts/projects/p-ts-contracts/smart_contracts/index.ts index d152f49..6030d0e 100644 --- a/examples/p-ts/projects/p-ts-contracts/smart_contracts/index.ts +++ b/examples/p-ts/projects/p-ts-contracts/smart_contracts/index.ts @@ -39,12 +39,12 @@ async function getDeployers() { } // execute all the deployers -;(async () => { +(async () => { const contractName = process.argv.length > 2 ? process.argv[2] : undefined const contractDeployers = await getDeployers() - + const filteredDeployers = contractName - ? contractDeployers.filter((deployer) => deployer.name === contractName) + ? contractDeployers.filter(deployer => deployer.name === contractName) : contractDeployers if (contractName && filteredDeployers.length === 0) { diff --git a/examples/p-ts/projects/p-ts-contracts/tsconfig.json b/examples/p-ts/projects/p-ts-contracts/tsconfig.json index a1e51b7..d989075 100644 --- a/examples/p-ts/projects/p-ts-contracts/tsconfig.json +++ b/examples/p-ts/projects/p-ts-contracts/tsconfig.json @@ -17,7 +17,9 @@ "resolveJsonModule": true, "isolatedModules": true, "noEmit": true, - "lib": ["ESNext"] + "lib": [ + "ESNext" + ], }, "include": ["smart_contracts/**/*.ts"], "exclude": ["node_modules", "dist", "coverage"] diff --git a/examples/p-ts/projects/p-ts-contracts/vitest.config.mts b/examples/p-ts/projects/p-ts-contracts/vitest.config.mts index 023dc0d..abb2d2a 100644 --- a/examples/p-ts/projects/p-ts-contracts/vitest.config.mts +++ b/examples/p-ts/projects/p-ts-contracts/vitest.config.mts @@ -4,7 +4,7 @@ import { defineConfig } from 'vitest/config' export default defineConfig({ esbuild: {}, - test: { + test: { testTimeout: 10000, coverage: { provider: 'v8', diff --git a/examples/p-ts/projects/p-ts-frontend/src/components/AppCalls.tsx b/examples/p-ts/projects/p-ts-frontend/src/components/AppCalls.tsx index 1268994..55fb808 100644 --- a/examples/p-ts/projects/p-ts-frontend/src/components/AppCalls.tsx +++ b/examples/p-ts/projects/p-ts-frontend/src/components/AppCalls.tsx @@ -5,6 +5,7 @@ import { HelloWorldFactory } from '../contracts/HelloWorld' import { OnSchemaBreak, OnUpdate } from '@algorandfoundation/algokit-utils/types/app' import { getAlgodConfigFromViteEnvironment, getIndexerConfigFromViteEnvironment } from '../utils/network/getAlgoClientConfigs' import { AlgorandClient } from '@algorandfoundation/algokit-utils' +import { encodeTransactionRaw } from '@algorandfoundation/algokit-utils/transact' interface AppCallsInterface { openModal: boolean @@ -15,7 +16,7 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { const [loading, setLoading] = useState(false) const [contractInput, setContractInput] = useState('') const { enqueueSnackbar } = useSnackbar() - const { transactionSigner, activeAddress } = useWallet() + const { signTransactions, activeAddress } = useWallet() const algodConfig = getAlgodConfigFromViteEnvironment() const indexerConfig = getIndexerConfigFromViteEnvironment() @@ -23,7 +24,11 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { algodConfig, indexerConfig, }) - algorand.setDefaultSigner(transactionSigner) + algorand.setDefaultSigner(async (txnGroup, indexesToSign) => { + const encoded = txnGroup.map((txn) => encodeTransactionRaw(txn)) + const signed = await signTransactions(encoded, indexesToSign) + return signed.filter((s): s is Uint8Array => s !== null) + }) const sendAppCall = async () => { setLoading(true) diff --git a/examples/s-py/projects/s-py-frontend/src/components/AppCalls.tsx b/examples/s-py/projects/s-py-frontend/src/components/AppCalls.tsx index 1268994..55fb808 100644 --- a/examples/s-py/projects/s-py-frontend/src/components/AppCalls.tsx +++ b/examples/s-py/projects/s-py-frontend/src/components/AppCalls.tsx @@ -5,6 +5,7 @@ import { HelloWorldFactory } from '../contracts/HelloWorld' import { OnSchemaBreak, OnUpdate } from '@algorandfoundation/algokit-utils/types/app' import { getAlgodConfigFromViteEnvironment, getIndexerConfigFromViteEnvironment } from '../utils/network/getAlgoClientConfigs' import { AlgorandClient } from '@algorandfoundation/algokit-utils' +import { encodeTransactionRaw } from '@algorandfoundation/algokit-utils/transact' interface AppCallsInterface { openModal: boolean @@ -15,7 +16,7 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { const [loading, setLoading] = useState(false) const [contractInput, setContractInput] = useState('') const { enqueueSnackbar } = useSnackbar() - const { transactionSigner, activeAddress } = useWallet() + const { signTransactions, activeAddress } = useWallet() const algodConfig = getAlgodConfigFromViteEnvironment() const indexerConfig = getIndexerConfigFromViteEnvironment() @@ -23,7 +24,11 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { algodConfig, indexerConfig, }) - algorand.setDefaultSigner(transactionSigner) + algorand.setDefaultSigner(async (txnGroup, indexesToSign) => { + const encoded = txnGroup.map((txn) => encodeTransactionRaw(txn)) + const signed = await signTransactions(encoded, indexesToSign) + return signed.filter((s): s is Uint8Array => s !== null) + }) const sendAppCall = async () => { setLoading(true) diff --git a/examples/s-py/projects/s-py-frontend/src/contracts/HelloWorld.ts b/examples/s-py/projects/s-py-frontend/src/contracts/HelloWorld.ts index 1fc6caf..d5f247a 100644 --- a/examples/s-py/projects/s-py-frontend/src/contracts/HelloWorld.ts +++ b/examples/s-py/projects/s-py-frontend/src/contracts/HelloWorld.ts @@ -24,7 +24,7 @@ import { SendParams, SendSingleTransactionResult, SendAtomicTransactionComposerR import { Address, encodeAddress, modelsv2, OnApplicationComplete, Transaction, TransactionSigner } from 'algosdk' import SimulateResponse = modelsv2.SimulateResponse -export const APP_SPEC: Arc56Contract = {"name":"HelloWorld","structs":{},"methods":[{"name":"hello","args":[{"type":"string","name":"name"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[37],"errorMessage":"OnCompletion must be NoOp && can only call when creating"},{"pc":[26],"errorMessage":"OnCompletion must be NoOp && can only call when not creating"},{"pc":[47],"errorMessage":"invalid array length header"},{"pc":[55],"errorMessage":"invalid number of bytes for arc4.dynamic_array"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"},"byteCode":{"approval":"CzEbQQAYgAQCvs4RNhoAjgEAAQAxGRQxGBBEQgALMRkUMRgUEESBAUM2GgFJgQBZgQIISwEVEkRXAgCAB0hlbGxvLCBMUEkVFlcGAkxQgAQVH3x1TFCwgQFD","clear":"C4EBQw=="},"compilerInfo":{"compiler":"puya","compilerVersion":{"major":5,"minor":4,"patch":0}},"events":[],"templateVariables":{}} as unknown as Arc56Contract +export const APP_SPEC: Arc56Contract = {"name":"HelloWorld","structs":{},"methods":[{"name":"hello","args":[{"type":"string","name":"name"}],"returns":{"type":"string"},"actions":{"create":[],"call":["NoOp"]},"readonly":false,"events":[],"recommendations":{}}],"arcs":[22,28],"networks":{},"state":{"schema":{"global":{"ints":0,"bytes":0},"local":{"ints":0,"bytes":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":["NoOp"],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"pc":[44],"errorMessage":"invalid array length header"},{"pc":[52],"errorMessage":"invalid number of bytes for arc4.dynamic_array"}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHNtYXJ0X2NvbnRyYWN0cy9oZWxsb193b3JsZC9jb250cmFjdC5weTo1CiAgICAvLyBjbGFzcyBIZWxsb1dvcmxkKEFSQzRDb250cmFjdCk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9fX2FsZ29weV9kZWZhdWx0X2NyZWF0ZUA1CiAgICBwdXNoYnl0ZXMgMHgwMmJlY2UxMSAvLyBtZXRob2QgImhlbGxvKHN0cmluZylzdHJpbmciCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCBtYWluX2hlbGxvX3JvdXRlQDMKICAgIGVycgoKbWFpbl9oZWxsb19yb3V0ZUAzOgogICAgLy8gc21hcnRfY29udHJhY3RzL2hlbGxvX3dvcmxkL2NvbnRyYWN0LnB5OjYKICAgIC8vIEBhYmltZXRob2QoKQogICAgdHhuIE9uQ29tcGxldGlvbgogICAgIQogICAgdHhuIEFwcGxpY2F0aW9uSUQKICAgICYmCiAgICBhc3NlcnQKICAgIGIgaGVsbG8KCm1haW5fX19hbGdvcHlfZGVmYXVsdF9jcmVhdGVANToKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICAhCiAgICAmJgogICAgcmV0dXJuCgoKLy8gc21hcnRfY29udHJhY3RzLmhlbGxvX3dvcmxkLmNvbnRyYWN0LkhlbGxvV29ybGQuaGVsbG9bcm91dGluZ10oKSAtPiB2b2lkOgpoZWxsbzoKICAgIC8vIHNtYXJ0X2NvbnRyYWN0cy9oZWxsb193b3JsZC9jb250cmFjdC5weTo2CiAgICAvLyBAYWJpbWV0aG9kKCkKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDEKICAgIGR1cAogICAgcHVzaGludCAwCiAgICBleHRyYWN0X3VpbnQxNiAvLyBvbiBlcnJvcjogaW52YWxpZCBhcnJheSBsZW5ndGggaGVhZGVyCiAgICBwdXNoaW50IDIKICAgICsKICAgIGRpZyAxCiAgICBsZW4KICAgID09CiAgICBhc3NlcnQgLy8gaW52YWxpZCBudW1iZXIgb2YgYnl0ZXMgZm9yIGFyYzQuZHluYW1pY19hcnJheTxhcmM0LnVpbnQ4PgogICAgZXh0cmFjdCAyIDAKICAgIC8vIHNtYXJ0X2NvbnRyYWN0cy9oZWxsb193b3JsZC9jb250cmFjdC5weTo4CiAgICAvLyByZXR1cm4gIkhlbGxvLCAiICsgbmFtZQogICAgcHVzaGJ5dGVzICJIZWxsbywgIgogICAgc3dhcAogICAgY29uY2F0CiAgICAvLyBzbWFydF9jb250cmFjdHMvaGVsbG9fd29ybGQvY29udHJhY3QucHk6NgogICAgLy8gQGFiaW1ldGhvZCgpCiAgICBkdXAKICAgIGxlbgogICAgaXRvYgogICAgZXh0cmFjdCA2IDIKICAgIHN3YXAKICAgIGNvbmNhdAogICAgcHVzaGJ5dGVzIDB4MTUxZjdjNzUKICAgIHN3YXAKICAgIGNvbmNhdAogICAgbG9nCiAgICBwdXNoaW50IDEKICAgIHJldHVybgo=","clear":"I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg=="},"byteCode":{"approval":"CzEbQQAYgAQCvs4RNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEM2GgFJgQBZgQIISwEVEkRXAgCAB0hlbGxvLCBMUEkVFlcGAkxQgAQVH3x1TFCwgQFD","clear":"C4EBQw=="},"compilerInfo":{"compiler":"puya","compilerVersion":{"major":5,"minor":7,"patch":1}},"events":[],"templateVariables":{}} as unknown as Arc56Contract /** * A state record containing binary data diff --git a/examples/s-tls/projects/s-tls-contracts/contracts/clients/CalculatorClient.ts b/examples/s-tls/projects/s-tls-contracts/contracts/clients/CalculatorClient.ts index ef4d4eb..d3674b9 100644 --- a/examples/s-tls/projects/s-tls-contracts/contracts/clients/CalculatorClient.ts +++ b/examples/s-tls/projects/s-tls-contracts/contracts/clients/CalculatorClient.ts @@ -24,7 +24,7 @@ import { SendParams, SendSingleTransactionResult, SendAtomicTransactionComposerR import { Address, encodeAddress, modelsv2, OnApplicationComplete, Transaction, TransactionSigner } from 'algosdk' import SimulateResponse = modelsv2.SimulateResponse -export const APP_SPEC: Arc56Contract = {"name":"Calculator","desc":"","methods":[{"name":"doMath","desc":"A method that takes two numbers and does either addition or subtraction","args":[{"name":"a","type":"uint64","desc":"The first uint64"},{"name":"b","type":"uint64","desc":"The second uint64"},{"name":"operation","type":"string","desc":"The operation to perform. Can be either 'sum' or 'difference'"}],"returns":{"type":"uint64","desc":"The result of the operation"},"actions":{"create":[],"call":["NoOp"]}},{"name":"hello","desc":"A demonstration method used in the AlgoKit fullstack template.\nGreets the user by name.","args":[{"name":"name","type":"string","desc":"The name of the user to greet."}],"returns":{"type":"string","desc":"A greeting message to the user."},"actions":{"create":[],"call":["NoOp"]}},{"name":"createApplication","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]}}],"arcs":[4,56],"structs":{},"state":{"schema":{"global":{"bytes":0,"ints":0},"local":{"bytes":0,"ints":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"teal":1,"source":"contracts/Calculator.algo.ts:3","pc":[0]},{"teal":2,"source":"contracts/Calculator.algo.ts:3","pc":[1,2,3]},{"teal":3,"source":"contracts/Calculator.algo.ts:3","pc":[4,5,6,7,8,9,10]},{"teal":15,"source":"contracts/Calculator.algo.ts:3","pc":[11,12]},{"teal":16,"source":"contracts/Calculator.algo.ts:3","pc":[13]},{"teal":17,"source":"contracts/Calculator.algo.ts:3","pc":[14,15]},{"teal":18,"source":"contracts/Calculator.algo.ts:3","pc":[16]},{"teal":19,"source":"contracts/Calculator.algo.ts:3","pc":[17,18]},{"teal":20,"source":"contracts/Calculator.algo.ts:3","pc":[19]},{"teal":21,"source":"contracts/Calculator.algo.ts:3","pc":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]},{"teal":25,"source":"contracts/Calculator.algo.ts:3","errorMessage":"The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?","pc":[46]},{"teal":35,"source":"contracts/Calculator.algo.ts:11","pc":[47,48,49]},{"teal":39,"source":"contracts/Calculator.algo.ts:12","pc":[50,51]},{"teal":40,"source":"contracts/Calculator.algo.ts:12","pc":[52,53]},{"teal":41,"source":"contracts/Calculator.algo.ts:12","pc":[54]},{"teal":42,"source":"contracts/Calculator.algo.ts:11","pc":[55]},{"teal":52,"source":"contracts/Calculator.algo.ts:22","pc":[56,57,58]},{"teal":56,"source":"contracts/Calculator.algo.ts:23","pc":[59,60]},{"teal":57,"source":"contracts/Calculator.algo.ts:23","pc":[61,62]},{"teal":58,"source":"contracts/Calculator.algo.ts:23","pc":[63]},{"teal":59,"source":"contracts/Calculator.algo.ts:23","pc":[64,65,66]},{"teal":60,"source":"contracts/Calculator.algo.ts:23","pc":[67,68]},{"teal":61,"source":"contracts/Calculator.algo.ts:23","pc":[69,70]},{"teal":62,"source":"contracts/Calculator.algo.ts:23","pc":[71]},{"teal":63,"source":"contracts/Calculator.algo.ts:23","pc":[72,73,74]},{"teal":66,"source":"contracts/Calculator.algo.ts:23","pc":[75,76]},{"teal":67,"source":"contracts/Calculator.algo.ts:23","pc":[77,78]},{"teal":68,"source":"contracts/Calculator.algo.ts:23","pc":[79]},{"teal":71,"source":"contracts/Calculator.algo.ts:22","pc":[80]},{"teal":76,"source":"contracts/Calculator.algo.ts:35","pc":[81]},{"teal":79,"source":"contracts/Calculator.algo.ts:35","pc":[82,83,84]},{"teal":80,"source":"contracts/Calculator.algo.ts:35","pc":[85,86,87]},{"teal":83,"source":"contracts/Calculator.algo.ts:35","pc":[88,89,90]},{"teal":84,"source":"contracts/Calculator.algo.ts:35","pc":[91]},{"teal":87,"source":"contracts/Calculator.algo.ts:35","pc":[92,93,94]},{"teal":88,"source":"contracts/Calculator.algo.ts:35","pc":[95]},{"teal":91,"source":"contracts/Calculator.algo.ts:35","pc":[96,97,98]},{"teal":92,"source":"contracts/Calculator.algo.ts:35","pc":[99]},{"teal":93,"source":"contracts/Calculator.algo.ts:35","pc":[100]},{"teal":94,"source":"contracts/Calculator.algo.ts:35","pc":[101]},{"teal":95,"source":"contracts/Calculator.algo.ts:35","pc":[102]},{"teal":96,"source":"contracts/Calculator.algo.ts:35","pc":[103]},{"teal":108,"source":"contracts/Calculator.algo.ts:35","pc":[104,105,106]},{"teal":111,"source":"contracts/Calculator.algo.ts:35","pc":[107,108]},{"teal":116,"source":"contracts/Calculator.algo.ts:38","pc":[109,110]},{"teal":117,"source":"contracts/Calculator.algo.ts:38","pc":[111,112,113,114,115]},{"teal":118,"source":"contracts/Calculator.algo.ts:38","pc":[116]},{"teal":119,"source":"contracts/Calculator.algo.ts:38","pc":[117,118,119]},{"teal":124,"source":"contracts/Calculator.algo.ts:39","pc":[120,121]},{"teal":125,"source":"contracts/Calculator.algo.ts:39","pc":[122,123]},{"teal":126,"source":"contracts/Calculator.algo.ts:39","pc":[124,125,126]},{"teal":127,"source":"contracts/Calculator.algo.ts:39","pc":[127,128]},{"teal":128,"source":"contracts/Calculator.algo.ts:38","pc":[129,130,131]},{"teal":133,"source":"contracts/Calculator.algo.ts:40","pc":[132,133]},{"teal":134,"source":"contracts/Calculator.algo.ts:40","pc":[134,135,136,137,138,139,140,141,142,143,144,145]},{"teal":135,"source":"contracts/Calculator.algo.ts:40","pc":[146]},{"teal":136,"source":"contracts/Calculator.algo.ts:40","pc":[147,148,149]},{"teal":141,"source":"contracts/Calculator.algo.ts:41","pc":[150,151]},{"teal":142,"source":"contracts/Calculator.algo.ts:41","pc":[152,153]},{"teal":143,"source":"contracts/Calculator.algo.ts:41","pc":[154,155,156]},{"teal":144,"source":"contracts/Calculator.algo.ts:41","pc":[157,158]},{"teal":145,"source":"contracts/Calculator.algo.ts:40","pc":[159,160,161]},{"teal":149,"source":"contracts/Calculator.algo.ts:42","errorMessage":"Invalid operation","pc":[162]},{"teal":154,"source":"contracts/Calculator.algo.ts:44","pc":[163,164]},{"teal":157,"source":"contracts/Calculator.algo.ts:35","pc":[165,166]},{"teal":158,"source":"contracts/Calculator.algo.ts:35","pc":[167]},{"teal":163,"source":"contracts/Calculator.algo.ts:54","pc":[168]},{"teal":166,"source":"contracts/Calculator.algo.ts:54","pc":[169,170,171]},{"teal":167,"source":"contracts/Calculator.algo.ts:54","pc":[172,173,174]},{"teal":170,"source":"contracts/Calculator.algo.ts:54","pc":[175,176,177]},{"teal":171,"source":"contracts/Calculator.algo.ts:54","pc":[178]},{"teal":172,"source":"contracts/Calculator.algo.ts:54","pc":[179]},{"teal":173,"source":"contracts/Calculator.algo.ts:54","pc":[180]},{"teal":174,"source":"contracts/Calculator.algo.ts:54","pc":[181,182,183]},{"teal":175,"source":"contracts/Calculator.algo.ts:54","pc":[184]},{"teal":176,"source":"contracts/Calculator.algo.ts:54","pc":[185]},{"teal":177,"source":"contracts/Calculator.algo.ts:54","pc":[186]},{"teal":178,"source":"contracts/Calculator.algo.ts:54","pc":[187]},{"teal":179,"source":"contracts/Calculator.algo.ts:54","pc":[188]},{"teal":180,"source":"contracts/Calculator.algo.ts:54","pc":[189]},{"teal":190,"source":"contracts/Calculator.algo.ts:54","pc":[190,191,192]},{"teal":194,"source":"contracts/Calculator.algo.ts:55","pc":[193,194,195,196,197,198,199,200,201]},{"teal":195,"source":"contracts/Calculator.algo.ts:55","pc":[202,203]},{"teal":196,"source":"contracts/Calculator.algo.ts:55","pc":[204]},{"teal":197,"source":"contracts/Calculator.algo.ts:54","pc":[205]},{"teal":200,"source":"contracts/Calculator.algo.ts:3","pc":[206]},{"teal":201,"source":"contracts/Calculator.algo.ts:3","pc":[207]},{"teal":204,"source":"contracts/Calculator.algo.ts:3","pc":[208,209,210,211,212,213]},{"teal":205,"source":"contracts/Calculator.algo.ts:3","pc":[214,215,216]},{"teal":206,"source":"contracts/Calculator.algo.ts:3","pc":[217,218,219,220]},{"teal":209,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for create NoOp","pc":[221]},{"teal":212,"source":"contracts/Calculator.algo.ts:3","pc":[222,223,224,225,226,227]},{"teal":213,"source":"contracts/Calculator.algo.ts:3","pc":[228,229,230,231,232,233]},{"teal":214,"source":"contracts/Calculator.algo.ts:3","pc":[234,235,236]},{"teal":215,"source":"contracts/Calculator.algo.ts:3","pc":[237,238,239,240,241,242]},{"teal":218,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for call NoOp","pc":[243]}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEw"},"byteCode":{"approval":"CiABASYBBBUffHUxGBSBBgsxGQiNDACwAAAAAAAAAAAAAACiAAAAAAAAAAAAAACKAgGL/4v+CImKAgGL/4v+D0EACIv/i/4JQgAFi/6L/wmJKDYaA1cCADYaAhc2GgEXiAAFFlCwIkOKAwGAAIv9gANzdW0SQQAMi/6L/4j/sIwAQgAfi/2ACmRpZmZlcmVuY2USQQAMi/6L/4j/m4wAQgABAIsAjACJKDYaAVcCAIgADEkVFlcGAkxQULAiQ4oBAYAHSGVsbG8sIIv/UIkiQ4AEuER7NjYaAI4B//EAgAR2p+8zgAQCvs4RNhoAjgL/Xv+1AA==","clear":"Cg=="},"compilerInfo":{"compiler":"algod","compilerVersion":{"major":4,"minor":4,"patch":1,"commitHash":"7b607ce4"}}} as unknown as Arc56Contract +export const APP_SPEC: Arc56Contract = {"name":"Calculator","desc":"","methods":[{"name":"doMath","desc":"A method that takes two numbers and does either addition or subtraction","args":[{"name":"a","type":"uint64","desc":"The first uint64"},{"name":"b","type":"uint64","desc":"The second uint64"},{"name":"operation","type":"string","desc":"The operation to perform. Can be either 'sum' or 'difference'"}],"returns":{"type":"uint64","desc":"The result of the operation"},"actions":{"create":[],"call":["NoOp"]}},{"name":"hello","desc":"A demonstration method used in the AlgoKit fullstack template.\nGreets the user by name.","args":[{"name":"name","type":"string","desc":"The name of the user to greet."}],"returns":{"type":"string","desc":"A greeting message to the user."},"actions":{"create":[],"call":["NoOp"]}},{"name":"createApplication","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]}}],"arcs":[4,56],"structs":{},"state":{"schema":{"global":{"bytes":0,"ints":0},"local":{"bytes":0,"ints":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"teal":1,"source":"contracts/Calculator.algo.ts:3","pc":[0]},{"teal":2,"source":"contracts/Calculator.algo.ts:3","pc":[1,2,3]},{"teal":3,"source":"contracts/Calculator.algo.ts:3","pc":[4,5,6,7,8,9,10]},{"teal":15,"source":"contracts/Calculator.algo.ts:3","pc":[11,12]},{"teal":16,"source":"contracts/Calculator.algo.ts:3","pc":[13]},{"teal":17,"source":"contracts/Calculator.algo.ts:3","pc":[14,15]},{"teal":18,"source":"contracts/Calculator.algo.ts:3","pc":[16]},{"teal":19,"source":"contracts/Calculator.algo.ts:3","pc":[17,18]},{"teal":20,"source":"contracts/Calculator.algo.ts:3","pc":[19]},{"teal":21,"source":"contracts/Calculator.algo.ts:3","pc":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]},{"teal":25,"source":"contracts/Calculator.algo.ts:3","errorMessage":"The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?","pc":[46]},{"teal":35,"source":"contracts/Calculator.algo.ts:11","pc":[47,48,49]},{"teal":39,"source":"contracts/Calculator.algo.ts:12","pc":[50,51]},{"teal":40,"source":"contracts/Calculator.algo.ts:12","pc":[52,53]},{"teal":41,"source":"contracts/Calculator.algo.ts:12","pc":[54]},{"teal":42,"source":"contracts/Calculator.algo.ts:11","pc":[55]},{"teal":52,"source":"contracts/Calculator.algo.ts:22","pc":[56,57,58]},{"teal":56,"source":"contracts/Calculator.algo.ts:23","pc":[59,60]},{"teal":57,"source":"contracts/Calculator.algo.ts:23","pc":[61,62]},{"teal":58,"source":"contracts/Calculator.algo.ts:23","pc":[63]},{"teal":59,"source":"contracts/Calculator.algo.ts:23","pc":[64,65,66]},{"teal":60,"source":"contracts/Calculator.algo.ts:23","pc":[67,68]},{"teal":61,"source":"contracts/Calculator.algo.ts:23","pc":[69,70]},{"teal":62,"source":"contracts/Calculator.algo.ts:23","pc":[71]},{"teal":63,"source":"contracts/Calculator.algo.ts:23","pc":[72,73,74]},{"teal":66,"source":"contracts/Calculator.algo.ts:23","pc":[75,76]},{"teal":67,"source":"contracts/Calculator.algo.ts:23","pc":[77,78]},{"teal":68,"source":"contracts/Calculator.algo.ts:23","pc":[79]},{"teal":71,"source":"contracts/Calculator.algo.ts:22","pc":[80]},{"teal":76,"source":"contracts/Calculator.algo.ts:35","pc":[81]},{"teal":79,"source":"contracts/Calculator.algo.ts:35","pc":[82,83,84]},{"teal":80,"source":"contracts/Calculator.algo.ts:35","pc":[85,86,87]},{"teal":83,"source":"contracts/Calculator.algo.ts:35","pc":[88,89,90]},{"teal":84,"source":"contracts/Calculator.algo.ts:35","pc":[91]},{"teal":87,"source":"contracts/Calculator.algo.ts:35","pc":[92,93,94]},{"teal":88,"source":"contracts/Calculator.algo.ts:35","pc":[95]},{"teal":91,"source":"contracts/Calculator.algo.ts:35","pc":[96,97,98]},{"teal":92,"source":"contracts/Calculator.algo.ts:35","pc":[99]},{"teal":93,"source":"contracts/Calculator.algo.ts:35","pc":[100]},{"teal":94,"source":"contracts/Calculator.algo.ts:35","pc":[101]},{"teal":95,"source":"contracts/Calculator.algo.ts:35","pc":[102]},{"teal":96,"source":"contracts/Calculator.algo.ts:35","pc":[103]},{"teal":108,"source":"contracts/Calculator.algo.ts:35","pc":[104,105,106]},{"teal":111,"source":"contracts/Calculator.algo.ts:35","pc":[107,108]},{"teal":116,"source":"contracts/Calculator.algo.ts:38","pc":[109,110]},{"teal":117,"source":"contracts/Calculator.algo.ts:38","pc":[111,112,113,114,115]},{"teal":118,"source":"contracts/Calculator.algo.ts:38","pc":[116]},{"teal":119,"source":"contracts/Calculator.algo.ts:38","pc":[117,118,119]},{"teal":124,"source":"contracts/Calculator.algo.ts:39","pc":[120,121]},{"teal":125,"source":"contracts/Calculator.algo.ts:39","pc":[122,123]},{"teal":126,"source":"contracts/Calculator.algo.ts:39","pc":[124,125,126]},{"teal":127,"source":"contracts/Calculator.algo.ts:39","pc":[127,128]},{"teal":128,"source":"contracts/Calculator.algo.ts:38","pc":[129,130,131]},{"teal":133,"source":"contracts/Calculator.algo.ts:40","pc":[132,133]},{"teal":134,"source":"contracts/Calculator.algo.ts:40","pc":[134,135,136,137,138,139,140,141,142,143,144,145]},{"teal":135,"source":"contracts/Calculator.algo.ts:40","pc":[146]},{"teal":136,"source":"contracts/Calculator.algo.ts:40","pc":[147,148,149]},{"teal":141,"source":"contracts/Calculator.algo.ts:41","pc":[150,151]},{"teal":142,"source":"contracts/Calculator.algo.ts:41","pc":[152,153]},{"teal":143,"source":"contracts/Calculator.algo.ts:41","pc":[154,155,156]},{"teal":144,"source":"contracts/Calculator.algo.ts:41","pc":[157,158]},{"teal":145,"source":"contracts/Calculator.algo.ts:40","pc":[159,160,161]},{"teal":149,"source":"contracts/Calculator.algo.ts:42","errorMessage":"Invalid operation","pc":[162]},{"teal":154,"source":"contracts/Calculator.algo.ts:44","pc":[163,164]},{"teal":157,"source":"contracts/Calculator.algo.ts:35","pc":[165,166]},{"teal":158,"source":"contracts/Calculator.algo.ts:35","pc":[167]},{"teal":163,"source":"contracts/Calculator.algo.ts:54","pc":[168]},{"teal":166,"source":"contracts/Calculator.algo.ts:54","pc":[169,170,171]},{"teal":167,"source":"contracts/Calculator.algo.ts:54","pc":[172,173,174]},{"teal":170,"source":"contracts/Calculator.algo.ts:54","pc":[175,176,177]},{"teal":171,"source":"contracts/Calculator.algo.ts:54","pc":[178]},{"teal":172,"source":"contracts/Calculator.algo.ts:54","pc":[179]},{"teal":173,"source":"contracts/Calculator.algo.ts:54","pc":[180]},{"teal":174,"source":"contracts/Calculator.algo.ts:54","pc":[181,182,183]},{"teal":175,"source":"contracts/Calculator.algo.ts:54","pc":[184]},{"teal":176,"source":"contracts/Calculator.algo.ts:54","pc":[185]},{"teal":177,"source":"contracts/Calculator.algo.ts:54","pc":[186]},{"teal":178,"source":"contracts/Calculator.algo.ts:54","pc":[187]},{"teal":179,"source":"contracts/Calculator.algo.ts:54","pc":[188]},{"teal":180,"source":"contracts/Calculator.algo.ts:54","pc":[189]},{"teal":190,"source":"contracts/Calculator.algo.ts:54","pc":[190,191,192]},{"teal":194,"source":"contracts/Calculator.algo.ts:55","pc":[193,194,195,196,197,198,199,200,201]},{"teal":195,"source":"contracts/Calculator.algo.ts:55","pc":[202,203]},{"teal":196,"source":"contracts/Calculator.algo.ts:55","pc":[204]},{"teal":197,"source":"contracts/Calculator.algo.ts:54","pc":[205]},{"teal":200,"source":"contracts/Calculator.algo.ts:3","pc":[206]},{"teal":201,"source":"contracts/Calculator.algo.ts:3","pc":[207]},{"teal":204,"source":"contracts/Calculator.algo.ts:3","pc":[208,209,210,211,212,213]},{"teal":205,"source":"contracts/Calculator.algo.ts:3","pc":[214,215,216]},{"teal":206,"source":"contracts/Calculator.algo.ts:3","pc":[217,218,219,220]},{"teal":209,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for create NoOp","pc":[221]},{"teal":212,"source":"contracts/Calculator.algo.ts:3","pc":[222,223,224,225,226,227]},{"teal":213,"source":"contracts/Calculator.algo.ts:3","pc":[228,229,230,231,232,233]},{"teal":214,"source":"contracts/Calculator.algo.ts:3","pc":[234,235,236]},{"teal":215,"source":"contracts/Calculator.algo.ts:3","pc":[237,238,239,240,241,242]},{"teal":218,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for call NoOp","pc":[243]}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEw"},"byteCode":{"approval":"CiABASYBBBUffHUxGBSBBgsxGQiNDACwAAAAAAAAAAAAAACiAAAAAAAAAAAAAACKAgGL/4v+CImKAgGL/4v+D0EACIv/i/4JQgAFi/6L/wmJKDYaA1cCADYaAhc2GgEXiAAFFlCwIkOKAwGAAIv9gANzdW0SQQAMi/6L/4j/sIwAQgAfi/2ACmRpZmZlcmVuY2USQQAMi/6L/4j/m4wAQgABAIsAjACJKDYaAVcCAIgADEkVFlcGAkxQULAiQ4oBAYAHSGVsbG8sIIv/UIkiQ4AEuER7NjYaAI4B//EAgAR2p+8zgAQCvs4RNhoAjgL/Xv+1AA==","clear":"Cg=="},"compilerInfo":{"compiler":"algod","compilerVersion":{"major":4,"minor":4,"patch":1,"commitHash":"7b607ce4"}}} as unknown as Arc56Contract /** * A state record containing binary data diff --git a/examples/s-tls/projects/s-tls-frontend/src/components/AppCalls.tsx b/examples/s-tls/projects/s-tls-frontend/src/components/AppCalls.tsx index 8a37e8d..a03f337 100644 --- a/examples/s-tls/projects/s-tls-frontend/src/components/AppCalls.tsx +++ b/examples/s-tls/projects/s-tls-frontend/src/components/AppCalls.tsx @@ -4,6 +4,7 @@ import { useState } from 'react' import { CalculatorFactory } from '../contracts/Calculator' import { getAlgodConfigFromViteEnvironment, getIndexerConfigFromViteEnvironment } from '../utils/network/getAlgoClientConfigs' import { AlgorandClient } from '@algorandfoundation/algokit-utils' +import { encodeTransactionRaw } from '@algorandfoundation/algokit-utils/transact' interface AppCallsInterface { openModal: boolean @@ -14,7 +15,7 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { const [loading, setLoading] = useState(false) const [contractInput, setContractInput] = useState('') const { enqueueSnackbar } = useSnackbar() - const { transactionSigner, activeAddress } = useWallet() + const { signTransactions, activeAddress } = useWallet() const algodConfig = getAlgodConfigFromViteEnvironment() const indexerConfig = getIndexerConfigFromViteEnvironment() @@ -22,7 +23,11 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { algodConfig, indexerConfig, }) - algorand.setDefaultSigner(transactionSigner) + algorand.setDefaultSigner(async (txnGroup, indexesToSign) => { + const encoded = txnGroup.map((txn) => encodeTransactionRaw(txn)) + const signed = await signTransactions(encoded, indexesToSign) + return signed.filter((s): s is Uint8Array => s !== null) + }) const sendAppCall = async () => { setLoading(true) diff --git a/examples/s-tls/projects/s-tls-frontend/src/contracts/Calculator.ts b/examples/s-tls/projects/s-tls-frontend/src/contracts/Calculator.ts index cc4657a..01af943 100644 --- a/examples/s-tls/projects/s-tls-frontend/src/contracts/Calculator.ts +++ b/examples/s-tls/projects/s-tls-frontend/src/contracts/Calculator.ts @@ -24,7 +24,7 @@ import { SendParams, SendSingleTransactionResult, SendAtomicTransactionComposerR import { Address, encodeAddress, modelsv2, OnApplicationComplete, Transaction, TransactionSigner } from 'algosdk' import SimulateResponse = modelsv2.SimulateResponse -export const APP_SPEC: Arc56Contract = {"name":"Calculator","desc":"","methods":[{"name":"doMath","desc":"A method that takes two numbers and does either addition or subtraction","args":[{"name":"a","type":"uint64","desc":"The first uint64"},{"name":"b","type":"uint64","desc":"The second uint64"},{"name":"operation","type":"string","desc":"The operation to perform. Can be either 'sum' or 'difference'"}],"returns":{"type":"uint64","desc":"The result of the operation"},"actions":{"create":[],"call":["NoOp"]}},{"name":"hello","desc":"A demonstration method used in the AlgoKit fullstack template.\nGreets the user by name.","args":[{"name":"name","type":"string","desc":"The name of the user to greet."}],"returns":{"type":"string","desc":"A greeting message to the user."},"actions":{"create":[],"call":["NoOp"]}},{"name":"createApplication","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]}}],"arcs":[4,56],"structs":{},"state":{"schema":{"global":{"bytes":0,"ints":0},"local":{"bytes":0,"ints":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"teal":1,"source":"contracts/Calculator.algo.ts:3","pc":[0]},{"teal":2,"source":"contracts/Calculator.algo.ts:3","pc":[1,2,3]},{"teal":3,"source":"contracts/Calculator.algo.ts:3","pc":[4,5,6,7,8,9,10]},{"teal":15,"source":"contracts/Calculator.algo.ts:3","pc":[11,12]},{"teal":16,"source":"contracts/Calculator.algo.ts:3","pc":[13]},{"teal":17,"source":"contracts/Calculator.algo.ts:3","pc":[14,15]},{"teal":18,"source":"contracts/Calculator.algo.ts:3","pc":[16]},{"teal":19,"source":"contracts/Calculator.algo.ts:3","pc":[17,18]},{"teal":20,"source":"contracts/Calculator.algo.ts:3","pc":[19]},{"teal":21,"source":"contracts/Calculator.algo.ts:3","pc":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]},{"teal":25,"source":"contracts/Calculator.algo.ts:3","errorMessage":"The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?","pc":[46]},{"teal":35,"source":"contracts/Calculator.algo.ts:11","pc":[47,48,49]},{"teal":39,"source":"contracts/Calculator.algo.ts:12","pc":[50,51]},{"teal":40,"source":"contracts/Calculator.algo.ts:12","pc":[52,53]},{"teal":41,"source":"contracts/Calculator.algo.ts:12","pc":[54]},{"teal":42,"source":"contracts/Calculator.algo.ts:11","pc":[55]},{"teal":52,"source":"contracts/Calculator.algo.ts:22","pc":[56,57,58]},{"teal":56,"source":"contracts/Calculator.algo.ts:23","pc":[59,60]},{"teal":57,"source":"contracts/Calculator.algo.ts:23","pc":[61,62]},{"teal":58,"source":"contracts/Calculator.algo.ts:23","pc":[63]},{"teal":59,"source":"contracts/Calculator.algo.ts:23","pc":[64,65,66]},{"teal":60,"source":"contracts/Calculator.algo.ts:23","pc":[67,68]},{"teal":61,"source":"contracts/Calculator.algo.ts:23","pc":[69,70]},{"teal":62,"source":"contracts/Calculator.algo.ts:23","pc":[71]},{"teal":63,"source":"contracts/Calculator.algo.ts:23","pc":[72,73,74]},{"teal":66,"source":"contracts/Calculator.algo.ts:23","pc":[75,76]},{"teal":67,"source":"contracts/Calculator.algo.ts:23","pc":[77,78]},{"teal":68,"source":"contracts/Calculator.algo.ts:23","pc":[79]},{"teal":71,"source":"contracts/Calculator.algo.ts:22","pc":[80]},{"teal":76,"source":"contracts/Calculator.algo.ts:35","pc":[81]},{"teal":79,"source":"contracts/Calculator.algo.ts:35","pc":[82,83,84]},{"teal":80,"source":"contracts/Calculator.algo.ts:35","pc":[85,86,87]},{"teal":83,"source":"contracts/Calculator.algo.ts:35","pc":[88,89,90]},{"teal":84,"source":"contracts/Calculator.algo.ts:35","pc":[91]},{"teal":87,"source":"contracts/Calculator.algo.ts:35","pc":[92,93,94]},{"teal":88,"source":"contracts/Calculator.algo.ts:35","pc":[95]},{"teal":91,"source":"contracts/Calculator.algo.ts:35","pc":[96,97,98]},{"teal":92,"source":"contracts/Calculator.algo.ts:35","pc":[99]},{"teal":93,"source":"contracts/Calculator.algo.ts:35","pc":[100]},{"teal":94,"source":"contracts/Calculator.algo.ts:35","pc":[101]},{"teal":95,"source":"contracts/Calculator.algo.ts:35","pc":[102]},{"teal":96,"source":"contracts/Calculator.algo.ts:35","pc":[103]},{"teal":108,"source":"contracts/Calculator.algo.ts:35","pc":[104,105,106]},{"teal":111,"source":"contracts/Calculator.algo.ts:35","pc":[107,108]},{"teal":116,"source":"contracts/Calculator.algo.ts:38","pc":[109,110]},{"teal":117,"source":"contracts/Calculator.algo.ts:38","pc":[111,112,113,114,115]},{"teal":118,"source":"contracts/Calculator.algo.ts:38","pc":[116]},{"teal":119,"source":"contracts/Calculator.algo.ts:38","pc":[117,118,119]},{"teal":124,"source":"contracts/Calculator.algo.ts:39","pc":[120,121]},{"teal":125,"source":"contracts/Calculator.algo.ts:39","pc":[122,123]},{"teal":126,"source":"contracts/Calculator.algo.ts:39","pc":[124,125,126]},{"teal":127,"source":"contracts/Calculator.algo.ts:39","pc":[127,128]},{"teal":128,"source":"contracts/Calculator.algo.ts:38","pc":[129,130,131]},{"teal":133,"source":"contracts/Calculator.algo.ts:40","pc":[132,133]},{"teal":134,"source":"contracts/Calculator.algo.ts:40","pc":[134,135,136,137,138,139,140,141,142,143,144,145]},{"teal":135,"source":"contracts/Calculator.algo.ts:40","pc":[146]},{"teal":136,"source":"contracts/Calculator.algo.ts:40","pc":[147,148,149]},{"teal":141,"source":"contracts/Calculator.algo.ts:41","pc":[150,151]},{"teal":142,"source":"contracts/Calculator.algo.ts:41","pc":[152,153]},{"teal":143,"source":"contracts/Calculator.algo.ts:41","pc":[154,155,156]},{"teal":144,"source":"contracts/Calculator.algo.ts:41","pc":[157,158]},{"teal":145,"source":"contracts/Calculator.algo.ts:40","pc":[159,160,161]},{"teal":149,"source":"contracts/Calculator.algo.ts:42","errorMessage":"Invalid operation","pc":[162]},{"teal":154,"source":"contracts/Calculator.algo.ts:44","pc":[163,164]},{"teal":157,"source":"contracts/Calculator.algo.ts:35","pc":[165,166]},{"teal":158,"source":"contracts/Calculator.algo.ts:35","pc":[167]},{"teal":163,"source":"contracts/Calculator.algo.ts:54","pc":[168]},{"teal":166,"source":"contracts/Calculator.algo.ts:54","pc":[169,170,171]},{"teal":167,"source":"contracts/Calculator.algo.ts:54","pc":[172,173,174]},{"teal":170,"source":"contracts/Calculator.algo.ts:54","pc":[175,176,177]},{"teal":171,"source":"contracts/Calculator.algo.ts:54","pc":[178]},{"teal":172,"source":"contracts/Calculator.algo.ts:54","pc":[179]},{"teal":173,"source":"contracts/Calculator.algo.ts:54","pc":[180]},{"teal":174,"source":"contracts/Calculator.algo.ts:54","pc":[181,182,183]},{"teal":175,"source":"contracts/Calculator.algo.ts:54","pc":[184]},{"teal":176,"source":"contracts/Calculator.algo.ts:54","pc":[185]},{"teal":177,"source":"contracts/Calculator.algo.ts:54","pc":[186]},{"teal":178,"source":"contracts/Calculator.algo.ts:54","pc":[187]},{"teal":179,"source":"contracts/Calculator.algo.ts:54","pc":[188]},{"teal":180,"source":"contracts/Calculator.algo.ts:54","pc":[189]},{"teal":190,"source":"contracts/Calculator.algo.ts:54","pc":[190,191,192]},{"teal":194,"source":"contracts/Calculator.algo.ts:55","pc":[193,194,195,196,197,198,199,200,201]},{"teal":195,"source":"contracts/Calculator.algo.ts:55","pc":[202,203]},{"teal":196,"source":"contracts/Calculator.algo.ts:55","pc":[204]},{"teal":197,"source":"contracts/Calculator.algo.ts:54","pc":[205]},{"teal":200,"source":"contracts/Calculator.algo.ts:3","pc":[206]},{"teal":201,"source":"contracts/Calculator.algo.ts:3","pc":[207]},{"teal":204,"source":"contracts/Calculator.algo.ts:3","pc":[208,209,210,211,212,213]},{"teal":205,"source":"contracts/Calculator.algo.ts:3","pc":[214,215,216]},{"teal":206,"source":"contracts/Calculator.algo.ts:3","pc":[217,218,219,220]},{"teal":209,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for create NoOp","pc":[221]},{"teal":212,"source":"contracts/Calculator.algo.ts:3","pc":[222,223,224,225,226,227]},{"teal":213,"source":"contracts/Calculator.algo.ts:3","pc":[228,229,230,231,232,233]},{"teal":214,"source":"contracts/Calculator.algo.ts:3","pc":[234,235,236]},{"teal":215,"source":"contracts/Calculator.algo.ts:3","pc":[237,238,239,240,241,242]},{"teal":218,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for call NoOp","pc":[243]}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEw"},"byteCode":{"approval":"CiABASYBBBUffHUxGBSBBgsxGQiNDACwAAAAAAAAAAAAAACiAAAAAAAAAAAAAACKAgGL/4v+CImKAgGL/4v+D0EACIv/i/4JQgAFi/6L/wmJKDYaA1cCADYaAhc2GgEXiAAFFlCwIkOKAwGAAIv9gANzdW0SQQAMi/6L/4j/sIwAQgAfi/2ACmRpZmZlcmVuY2USQQAMi/6L/4j/m4wAQgABAIsAjACJKDYaAVcCAIgADEkVFlcGAkxQULAiQ4oBAYAHSGVsbG8sIIv/UIkiQ4AEuER7NjYaAI4B//EAgAR2p+8zgAQCvs4RNhoAjgL/Xv+1AA==","clear":"Cg=="},"compilerInfo":{"compiler":"algod","compilerVersion":{"major":4,"minor":4,"patch":1,"commitHash":"7b607ce4"}}} as unknown as Arc56Contract +export const APP_SPEC: Arc56Contract = {"name":"Calculator","desc":"","methods":[{"name":"doMath","desc":"A method that takes two numbers and does either addition or subtraction","args":[{"name":"a","type":"uint64","desc":"The first uint64"},{"name":"b","type":"uint64","desc":"The second uint64"},{"name":"operation","type":"string","desc":"The operation to perform. Can be either 'sum' or 'difference'"}],"returns":{"type":"uint64","desc":"The result of the operation"},"actions":{"create":[],"call":["NoOp"]}},{"name":"hello","desc":"A demonstration method used in the AlgoKit fullstack template.\nGreets the user by name.","args":[{"name":"name","type":"string","desc":"The name of the user to greet."}],"returns":{"type":"string","desc":"A greeting message to the user."},"actions":{"create":[],"call":["NoOp"]}},{"name":"createApplication","args":[],"returns":{"type":"void"},"actions":{"create":["NoOp"],"call":[]}}],"arcs":[4,56],"structs":{},"state":{"schema":{"global":{"bytes":0,"ints":0},"local":{"bytes":0,"ints":0}},"keys":{"global":{},"local":{},"box":{}},"maps":{"global":{},"local":{},"box":{}}},"bareActions":{"create":[],"call":[]},"sourceInfo":{"approval":{"sourceInfo":[{"teal":1,"source":"contracts/Calculator.algo.ts:3","pc":[0]},{"teal":2,"source":"contracts/Calculator.algo.ts:3","pc":[1,2,3]},{"teal":3,"source":"contracts/Calculator.algo.ts:3","pc":[4,5,6,7,8,9,10]},{"teal":15,"source":"contracts/Calculator.algo.ts:3","pc":[11,12]},{"teal":16,"source":"contracts/Calculator.algo.ts:3","pc":[13]},{"teal":17,"source":"contracts/Calculator.algo.ts:3","pc":[14,15]},{"teal":18,"source":"contracts/Calculator.algo.ts:3","pc":[16]},{"teal":19,"source":"contracts/Calculator.algo.ts:3","pc":[17,18]},{"teal":20,"source":"contracts/Calculator.algo.ts:3","pc":[19]},{"teal":21,"source":"contracts/Calculator.algo.ts:3","pc":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45]},{"teal":25,"source":"contracts/Calculator.algo.ts:3","errorMessage":"The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?","pc":[46]},{"teal":35,"source":"contracts/Calculator.algo.ts:11","pc":[47,48,49]},{"teal":39,"source":"contracts/Calculator.algo.ts:12","pc":[50,51]},{"teal":40,"source":"contracts/Calculator.algo.ts:12","pc":[52,53]},{"teal":41,"source":"contracts/Calculator.algo.ts:12","pc":[54]},{"teal":42,"source":"contracts/Calculator.algo.ts:11","pc":[55]},{"teal":52,"source":"contracts/Calculator.algo.ts:22","pc":[56,57,58]},{"teal":56,"source":"contracts/Calculator.algo.ts:23","pc":[59,60]},{"teal":57,"source":"contracts/Calculator.algo.ts:23","pc":[61,62]},{"teal":58,"source":"contracts/Calculator.algo.ts:23","pc":[63]},{"teal":59,"source":"contracts/Calculator.algo.ts:23","pc":[64,65,66]},{"teal":60,"source":"contracts/Calculator.algo.ts:23","pc":[67,68]},{"teal":61,"source":"contracts/Calculator.algo.ts:23","pc":[69,70]},{"teal":62,"source":"contracts/Calculator.algo.ts:23","pc":[71]},{"teal":63,"source":"contracts/Calculator.algo.ts:23","pc":[72,73,74]},{"teal":66,"source":"contracts/Calculator.algo.ts:23","pc":[75,76]},{"teal":67,"source":"contracts/Calculator.algo.ts:23","pc":[77,78]},{"teal":68,"source":"contracts/Calculator.algo.ts:23","pc":[79]},{"teal":71,"source":"contracts/Calculator.algo.ts:22","pc":[80]},{"teal":76,"source":"contracts/Calculator.algo.ts:35","pc":[81]},{"teal":79,"source":"contracts/Calculator.algo.ts:35","pc":[82,83,84]},{"teal":80,"source":"contracts/Calculator.algo.ts:35","pc":[85,86,87]},{"teal":83,"source":"contracts/Calculator.algo.ts:35","pc":[88,89,90]},{"teal":84,"source":"contracts/Calculator.algo.ts:35","pc":[91]},{"teal":87,"source":"contracts/Calculator.algo.ts:35","pc":[92,93,94]},{"teal":88,"source":"contracts/Calculator.algo.ts:35","pc":[95]},{"teal":91,"source":"contracts/Calculator.algo.ts:35","pc":[96,97,98]},{"teal":92,"source":"contracts/Calculator.algo.ts:35","pc":[99]},{"teal":93,"source":"contracts/Calculator.algo.ts:35","pc":[100]},{"teal":94,"source":"contracts/Calculator.algo.ts:35","pc":[101]},{"teal":95,"source":"contracts/Calculator.algo.ts:35","pc":[102]},{"teal":96,"source":"contracts/Calculator.algo.ts:35","pc":[103]},{"teal":108,"source":"contracts/Calculator.algo.ts:35","pc":[104,105,106]},{"teal":111,"source":"contracts/Calculator.algo.ts:35","pc":[107,108]},{"teal":116,"source":"contracts/Calculator.algo.ts:38","pc":[109,110]},{"teal":117,"source":"contracts/Calculator.algo.ts:38","pc":[111,112,113,114,115]},{"teal":118,"source":"contracts/Calculator.algo.ts:38","pc":[116]},{"teal":119,"source":"contracts/Calculator.algo.ts:38","pc":[117,118,119]},{"teal":124,"source":"contracts/Calculator.algo.ts:39","pc":[120,121]},{"teal":125,"source":"contracts/Calculator.algo.ts:39","pc":[122,123]},{"teal":126,"source":"contracts/Calculator.algo.ts:39","pc":[124,125,126]},{"teal":127,"source":"contracts/Calculator.algo.ts:39","pc":[127,128]},{"teal":128,"source":"contracts/Calculator.algo.ts:38","pc":[129,130,131]},{"teal":133,"source":"contracts/Calculator.algo.ts:40","pc":[132,133]},{"teal":134,"source":"contracts/Calculator.algo.ts:40","pc":[134,135,136,137,138,139,140,141,142,143,144,145]},{"teal":135,"source":"contracts/Calculator.algo.ts:40","pc":[146]},{"teal":136,"source":"contracts/Calculator.algo.ts:40","pc":[147,148,149]},{"teal":141,"source":"contracts/Calculator.algo.ts:41","pc":[150,151]},{"teal":142,"source":"contracts/Calculator.algo.ts:41","pc":[152,153]},{"teal":143,"source":"contracts/Calculator.algo.ts:41","pc":[154,155,156]},{"teal":144,"source":"contracts/Calculator.algo.ts:41","pc":[157,158]},{"teal":145,"source":"contracts/Calculator.algo.ts:40","pc":[159,160,161]},{"teal":149,"source":"contracts/Calculator.algo.ts:42","errorMessage":"Invalid operation","pc":[162]},{"teal":154,"source":"contracts/Calculator.algo.ts:44","pc":[163,164]},{"teal":157,"source":"contracts/Calculator.algo.ts:35","pc":[165,166]},{"teal":158,"source":"contracts/Calculator.algo.ts:35","pc":[167]},{"teal":163,"source":"contracts/Calculator.algo.ts:54","pc":[168]},{"teal":166,"source":"contracts/Calculator.algo.ts:54","pc":[169,170,171]},{"teal":167,"source":"contracts/Calculator.algo.ts:54","pc":[172,173,174]},{"teal":170,"source":"contracts/Calculator.algo.ts:54","pc":[175,176,177]},{"teal":171,"source":"contracts/Calculator.algo.ts:54","pc":[178]},{"teal":172,"source":"contracts/Calculator.algo.ts:54","pc":[179]},{"teal":173,"source":"contracts/Calculator.algo.ts:54","pc":[180]},{"teal":174,"source":"contracts/Calculator.algo.ts:54","pc":[181,182,183]},{"teal":175,"source":"contracts/Calculator.algo.ts:54","pc":[184]},{"teal":176,"source":"contracts/Calculator.algo.ts:54","pc":[185]},{"teal":177,"source":"contracts/Calculator.algo.ts:54","pc":[186]},{"teal":178,"source":"contracts/Calculator.algo.ts:54","pc":[187]},{"teal":179,"source":"contracts/Calculator.algo.ts:54","pc":[188]},{"teal":180,"source":"contracts/Calculator.algo.ts:54","pc":[189]},{"teal":190,"source":"contracts/Calculator.algo.ts:54","pc":[190,191,192]},{"teal":194,"source":"contracts/Calculator.algo.ts:55","pc":[193,194,195,196,197,198,199,200,201]},{"teal":195,"source":"contracts/Calculator.algo.ts:55","pc":[202,203]},{"teal":196,"source":"contracts/Calculator.algo.ts:55","pc":[204]},{"teal":197,"source":"contracts/Calculator.algo.ts:54","pc":[205]},{"teal":200,"source":"contracts/Calculator.algo.ts:3","pc":[206]},{"teal":201,"source":"contracts/Calculator.algo.ts:3","pc":[207]},{"teal":204,"source":"contracts/Calculator.algo.ts:3","pc":[208,209,210,211,212,213]},{"teal":205,"source":"contracts/Calculator.algo.ts:3","pc":[214,215,216]},{"teal":206,"source":"contracts/Calculator.algo.ts:3","pc":[217,218,219,220]},{"teal":209,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for create NoOp","pc":[221]},{"teal":212,"source":"contracts/Calculator.algo.ts:3","pc":[222,223,224,225,226,227]},{"teal":213,"source":"contracts/Calculator.algo.ts:3","pc":[228,229,230,231,232,233]},{"teal":214,"source":"contracts/Calculator.algo.ts:3","pc":[234,235,236]},{"teal":215,"source":"contracts/Calculator.algo.ts:3","pc":[237,238,239,240,241,242]},{"teal":218,"source":"contracts/Calculator.algo.ts:3","errorMessage":"this contract does not implement the given ABI method for call NoOp","pc":[243]}],"pcOffsetMethod":"none"},"clear":{"sourceInfo":[],"pcOffsetMethod":"none"}},"source":{"approval":"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","clear":"I3ByYWdtYSB2ZXJzaW9uIDEw"},"byteCode":{"approval":"CiABASYBBBUffHUxGBSBBgsxGQiNDACwAAAAAAAAAAAAAACiAAAAAAAAAAAAAACKAgGL/4v+CImKAgGL/4v+D0EACIv/i/4JQgAFi/6L/wmJKDYaA1cCADYaAhc2GgEXiAAFFlCwIkOKAwGAAIv9gANzdW0SQQAMi/6L/4j/sIwAQgAfi/2ACmRpZmZlcmVuY2USQQAMi/6L/4j/m4wAQgABAIsAjACJKDYaAVcCAIgADEkVFlcGAkxQULAiQ4oBAYAHSGVsbG8sIIv/UIkiQ4AEuER7NjYaAI4B//EAgAR2p+8zgAQCvs4RNhoAjgL/Xv+1AA==","clear":"Cg=="},"compilerInfo":{"compiler":"algod","compilerVersion":{"major":4,"minor":4,"patch":1,"commitHash":"7b607ce4"}}} as unknown as Arc56Contract /** * A state record containing binary data diff --git a/examples/s-ts/projects/s-ts-frontend/src/components/AppCalls.tsx b/examples/s-ts/projects/s-ts-frontend/src/components/AppCalls.tsx index 1268994..55fb808 100644 --- a/examples/s-ts/projects/s-ts-frontend/src/components/AppCalls.tsx +++ b/examples/s-ts/projects/s-ts-frontend/src/components/AppCalls.tsx @@ -5,6 +5,7 @@ import { HelloWorldFactory } from '../contracts/HelloWorld' import { OnSchemaBreak, OnUpdate } from '@algorandfoundation/algokit-utils/types/app' import { getAlgodConfigFromViteEnvironment, getIndexerConfigFromViteEnvironment } from '../utils/network/getAlgoClientConfigs' import { AlgorandClient } from '@algorandfoundation/algokit-utils' +import { encodeTransactionRaw } from '@algorandfoundation/algokit-utils/transact' interface AppCallsInterface { openModal: boolean @@ -15,7 +16,7 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { const [loading, setLoading] = useState(false) const [contractInput, setContractInput] = useState('') const { enqueueSnackbar } = useSnackbar() - const { transactionSigner, activeAddress } = useWallet() + const { signTransactions, activeAddress } = useWallet() const algodConfig = getAlgodConfigFromViteEnvironment() const indexerConfig = getIndexerConfigFromViteEnvironment() @@ -23,7 +24,11 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { algodConfig, indexerConfig, }) - algorand.setDefaultSigner(transactionSigner) + algorand.setDefaultSigner(async (txnGroup, indexesToSign) => { + const encoded = txnGroup.map((txn) => encodeTransactionRaw(txn)) + const signed = await signTransactions(encoded, indexesToSign) + return signed.filter((s): s is Uint8Array => s !== null) + }) const sendAppCall = async () => { setLoading(true) diff --git a/pytest-junit.xml b/pytest-junit.xml new file mode 100644 index 0000000..6b466e9 --- /dev/null +++ b/pytest-junit.xml @@ -0,0 +1,267 @@ +contract_template = 'python' +working_dir = PosixPath('/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template') + + @pytest.mark.parametrize("contract_template", contract_templates) + def test_production_preset(contract_template: str, working_dir: Path) -> None: + response = run_init( + working_dir, + f"p-{short_contract_templates[contract_template]}", + answers=get_answered_questions_from_copier_yaml( + preset_name="production", + deployment_language="python", + contract_template=contract_template, + ), + child_template_default_answer="y", + ) + +> assert response.returncode == 0, response.stdout +E AssertionError: DEBUG: Running ['/usr/bin/git', '-C', '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template', 'rev-parse', '--is-shallow-repository'] +E DEBUG: Running ['/usr/bin/git', 'clone', '--no-checkout', '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template', '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.0pdwuvj0', '--filter=blob:none'] +E DEBUG: Chdir to /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.0pdwuvj0 +E DEBUG: Running ['/usr/bin/git', '-c', 'core.fsmonitor=false', 'checkout', '-f', 'prep/beta-release'] +E DEBUG: Running ['/usr/bin/git', 'submodule', 'update', '--checkout', '--init', '--recursive', '--force'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.0pdwuvj0 +E DEBUG: Running ['/usr/bin/git', 'describe', '--tags', '--always'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: final clone URL = /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-py +E ==== 1/4 - Initializing base template ==== +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-py +E WARNING: Failed to get user info from git, please input your 'name' manually or use default placeholder. +E WARNING: Failed to get user info from git, please input your 'email' manually or use default placeholder. +E Starting template copy and render at /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-py... +E Unhandled ProcessExecutionError: Unexpected exit code: 128 +E Command line: | /usr/bin/git clone --no-checkout https://github.com/algorandfoundation/algokit-base-template.git /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.yetmhf0g --filter=blob:none +E Stderr: | Cloning into '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.yetmhf0g'... +E | fatal: unable to access 'https://github.com/algorandfoundation/algokit-base-template.git/': Could not resolve host: github.com +E [PYI-59715:ERROR] Failed to execute script '__main__' due to unhandled exception! +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E Unhandled TaskError: Command 'algokit init -t base -n . --no-git --no-ide --no-bootstrap --no-workspace -a include_readme "no" -a include_algokit_toml "no" -a include_vscode_code_workspace "no" -a include_github_workflow_template "no"' returned non-zero exit status 1. +E [PYI-59668:ERROR] Failed to execute script '__main__' due to unhandled exception! +E +E assert 1 == 0 +E + where 1 = CompletedProcess(args=['algokit', '--verbose', 'init', '--name', 'p-py', '--template-url', '/var/folders/96/k83m8nkj3t...turned non-zero exit status 1.\n[PYI-59668:ERROR] Failed to execute script \'__main__\' due to unhandled exception!\n').returncode + +tests/test_templates.py:288: AssertionErrorcontract_template = 'tealscript' +working_dir = PosixPath('/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template') + + @pytest.mark.parametrize("contract_template", contract_templates) + def test_production_preset(contract_template: str, working_dir: Path) -> None: + response = run_init( + working_dir, + f"p-{short_contract_templates[contract_template]}", + answers=get_answered_questions_from_copier_yaml( + preset_name="production", + deployment_language="python", + contract_template=contract_template, + ), + child_template_default_answer="y", + ) + +> assert response.returncode == 0, response.stdout +E AssertionError: DEBUG: Chdir to /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.v39cv6gu +E DEBUG: Running ['/usr/bin/git', '-c', 'core.fsmonitor=false', 'checkout', '-f', 'prep/beta-release'] +E DEBUG: Running ['/usr/bin/git', 'submodule', 'update', '--checkout', '--init', '--recursive', '--force'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.v39cv6gu +E DEBUG: Running ['/usr/bin/git', 'describe', '--tags', '--always'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: final clone URL = /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-tls +E ==== 1/4 - Initializing base template ==== +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-tls +E WARNING: Failed to get user info from git, please input your 'name' manually or use default placeholder. +E WARNING: Failed to get user info from git, please input your 'email' manually or use default placeholder. +E Starting template copy and render at /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-tls... +E Unhandled ProcessExecutionError: Unexpected exit code: 128 +E Command line: | /usr/bin/git clone --no-checkout https://github.com/algorandfoundation/algokit-base-template.git /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.ghyu4ug8 --filter=blob:none +E Stderr: | Cloning into '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.ghyu4ug8'... +E | fatal: unable to access 'https://github.com/algorandfoundation/algokit-base-template.git/': Could not resolve host: github.com +E [PYI-59772:ERROR] Failed to execute script '__main__' due to unhandled exception! +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E Unhandled TaskError: Command 'algokit init -t base -n . --no-git --no-ide --no-bootstrap --no-workspace -a include_readme "no" -a include_algokit_toml "no" -a include_vscode_code_workspace "no" -a include_github_workflow_template "no"' returned non-zero exit status 1. +E [PYI-59725:ERROR] Failed to execute script '__main__' due to unhandled exception! +E +E assert 1 == 0 +E + where 1 = CompletedProcess(args=['algokit', '--verbose', 'init', '--name', 'p-tls', '--template-url', '/var/folders/96/k83m8nkj3...turned non-zero exit status 1.\n[PYI-59725:ERROR] Failed to execute script \'__main__\' due to unhandled exception!\n').returncode + +tests/test_templates.py:288: AssertionErrorcontract_template = 'typescript' +working_dir = PosixPath('/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template') + + @pytest.mark.parametrize("contract_template", contract_templates) + def test_production_preset(contract_template: str, working_dir: Path) -> None: + response = run_init( + working_dir, + f"p-{short_contract_templates[contract_template]}", + answers=get_answered_questions_from_copier_yaml( + preset_name="production", + deployment_language="python", + contract_template=contract_template, + ), + child_template_default_answer="y", + ) + +> assert response.returncode == 0, response.stdout +E AssertionError: DEBUG: Chdir to /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.i3ytp2qd +E DEBUG: Running ['/usr/bin/git', '-c', 'core.fsmonitor=false', 'checkout', '-f', 'prep/beta-release'] +E DEBUG: Running ['/usr/bin/git', 'submodule', 'update', '--checkout', '--init', '--recursive', '--force'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.i3ytp2qd +E DEBUG: Running ['/usr/bin/git', 'describe', '--tags', '--always'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: final clone URL = /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-ts +E ==== 1/4 - Initializing base template ==== +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-ts +E WARNING: Failed to get user info from git, please input your 'name' manually or use default placeholder. +E WARNING: Failed to get user info from git, please input your 'email' manually or use default placeholder. +E Starting template copy and render at /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/p-ts... +E Unhandled ProcessExecutionError: Unexpected exit code: 128 +E Command line: | /usr/bin/git clone --no-checkout https://github.com/algorandfoundation/algokit-base-template.git /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.45rezklr --filter=blob:none +E Stderr: | Cloning into '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.45rezklr'... +E | fatal: unable to access 'https://github.com/algorandfoundation/algokit-base-template.git/': Could not resolve host: github.com +E [PYI-59829:ERROR] Failed to execute script '__main__' due to unhandled exception! +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E Unhandled TaskError: Command 'algokit init -t base -n . --no-git --no-ide --no-bootstrap --no-workspace -a include_readme "no" -a include_algokit_toml "no" -a include_vscode_code_workspace "no" -a include_github_workflow_template "no"' returned non-zero exit status 1. +E [PYI-59782:ERROR] Failed to execute script '__main__' due to unhandled exception! +E +E assert 1 == 0 +E + where 1 = CompletedProcess(args=['algokit', '--verbose', 'init', '--name', 'p-ts', '--template-url', '/var/folders/96/k83m8nkj3t...turned non-zero exit status 1.\n[PYI-59782:ERROR] Failed to execute script \'__main__\' due to unhandled exception!\n').returncode + +tests/test_templates.py:288: AssertionErrorcontract_template = 'python' +working_dir = PosixPath('/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template') + + @pytest.mark.parametrize("contract_template", contract_templates) + def test_starter_preset(contract_template: str, working_dir: Path) -> None: + response = run_init( + working_dir, + f"s-{short_contract_templates[contract_template]}", + answers=get_answered_questions_from_copier_yaml( + preset_name="starter", + deployment_language="typescript", + contract_template=contract_template, + ), + child_template_default_answer="n", + ) + +> assert response.returncode == 0, response.stdout +E AssertionError: DEBUG: Chdir to /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.z4wjkl5s +E DEBUG: Running ['/usr/bin/git', '-c', 'core.fsmonitor=false', 'checkout', '-f', 'prep/beta-release'] +E DEBUG: Running ['/usr/bin/git', 'submodule', 'update', '--checkout', '--init', '--recursive', '--force'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.z4wjkl5s +E DEBUG: Running ['/usr/bin/git', 'describe', '--tags', '--always'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: final clone URL = /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-py +E ==== 1/4 - Initializing base template ==== +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-py +E WARNING: Failed to get user info from git, please input your 'name' manually or use default placeholder. +E WARNING: Failed to get user info from git, please input your 'email' manually or use default placeholder. +E Starting template copy and render at /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-py... +E Unhandled ProcessExecutionError: Unexpected exit code: 128 +E Command line: | /usr/bin/git clone --no-checkout https://github.com/algorandfoundation/algokit-base-template.git /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.fanwhd7i --filter=blob:none +E Stderr: | Cloning into '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.fanwhd7i'... +E | fatal: unable to access 'https://github.com/algorandfoundation/algokit-base-template.git/': Could not resolve host: github.com +E [PYI-59887:ERROR] Failed to execute script '__main__' due to unhandled exception! +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E Unhandled TaskError: Command 'algokit init -t base -n . --no-git --no-ide --no-bootstrap --no-workspace -a include_readme "no" -a include_algokit_toml "no" -a include_vscode_code_workspace "no" -a include_github_workflow_template "no"' returned non-zero exit status 1. +E [PYI-59840:ERROR] Failed to execute script '__main__' due to unhandled exception! +E +E assert 1 == 0 +E + where 1 = CompletedProcess(args=['algokit', '--verbose', 'init', '--name', 's-py', '--template-url', '/var/folders/96/k83m8nkj3t...turned non-zero exit status 1.\n[PYI-59840:ERROR] Failed to execute script \'__main__\' due to unhandled exception!\n').returncode + +tests/test_templates.py:304: AssertionErrorcontract_template = 'tealscript' +working_dir = PosixPath('/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template') + + @pytest.mark.parametrize("contract_template", contract_templates) + def test_starter_preset(contract_template: str, working_dir: Path) -> None: + response = run_init( + working_dir, + f"s-{short_contract_templates[contract_template]}", + answers=get_answered_questions_from_copier_yaml( + preset_name="starter", + deployment_language="typescript", + contract_template=contract_template, + ), + child_template_default_answer="n", + ) + +> assert response.returncode == 0, response.stdout +E AssertionError: DEBUG: Chdir to /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.xfp1u9ig +E DEBUG: Running ['/usr/bin/git', '-c', 'core.fsmonitor=false', 'checkout', '-f', 'prep/beta-release'] +E DEBUG: Running ['/usr/bin/git', 'submodule', 'update', '--checkout', '--init', '--recursive', '--force'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.xfp1u9ig +E DEBUG: Running ['/usr/bin/git', 'describe', '--tags', '--always'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: final clone URL = /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-tls +E ==== 1/4 - Initializing base template ==== +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-tls +E WARNING: Failed to get user info from git, please input your 'name' manually or use default placeholder. +E WARNING: Failed to get user info from git, please input your 'email' manually or use default placeholder. +E Starting template copy and render at /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-tls... +E Unhandled ProcessExecutionError: Unexpected exit code: 128 +E Command line: | /usr/bin/git clone --no-checkout https://github.com/algorandfoundation/algokit-base-template.git /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.mnwppdyj --filter=blob:none +E Stderr: | Cloning into '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.mnwppdyj'... +E | fatal: unable to access 'https://github.com/algorandfoundation/algokit-base-template.git/': Could not resolve host: github.com +E [PYI-59944:ERROR] Failed to execute script '__main__' due to unhandled exception! +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E Unhandled TaskError: Command 'algokit init -t base -n . --no-git --no-ide --no-bootstrap --no-workspace -a include_readme "no" -a include_algokit_toml "no" -a include_vscode_code_workspace "no" -a include_github_workflow_template "no"' returned non-zero exit status 1. +E [PYI-59897:ERROR] Failed to execute script '__main__' due to unhandled exception! +E +E assert 1 == 0 +E + where 1 = CompletedProcess(args=['algokit', '--verbose', 'init', '--name', 's-tls', '--template-url', '/var/folders/96/k83m8nkj3...turned non-zero exit status 1.\n[PYI-59897:ERROR] Failed to execute script \'__main__\' due to unhandled exception!\n').returncode + +tests/test_templates.py:304: AssertionErrorcontract_template = 'typescript' +working_dir = PosixPath('/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template') + + @pytest.mark.parametrize("contract_template", contract_templates) + def test_starter_preset(contract_template: str, working_dir: Path) -> None: + response = run_init( + working_dir, + f"s-{short_contract_templates[contract_template]}", + answers=get_answered_questions_from_copier_yaml( + preset_name="starter", + deployment_language="typescript", + contract_template=contract_template, + ), + child_template_default_answer="n", + ) + +> assert response.returncode == 0, response.stdout +E AssertionError: DEBUG: Chdir to /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.bc0xynky +E DEBUG: Running ['/usr/bin/git', '-c', 'core.fsmonitor=false', 'checkout', '-f', 'prep/beta-release'] +E DEBUG: Running ['/usr/bin/git', 'submodule', 'update', '--checkout', '--init', '--recursive', '--force'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.bc0xynky +E DEBUG: Running ['/usr/bin/git', 'describe', '--tags', '--always'] +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: final clone URL = /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-ts +E ==== 1/4 - Initializing base template ==== +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-ts +E WARNING: Failed to get user info from git, please input your 'name' manually or use default placeholder. +E WARNING: Failed to get user info from git, please input your 'email' manually or use default placeholder. +E Starting template copy and render at /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples/s-ts... +E Unhandled ProcessExecutionError: Unexpected exit code: 128 +E Command line: | /usr/bin/git clone --no-checkout https://github.com/algorandfoundation/algokit-base-template.git /var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.fz6jg14s --filter=blob:none +E Stderr: | Cloning into '/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/copier._vcs.clone.fz6jg14s'... +E | fatal: unable to access 'https://github.com/algorandfoundation/algokit-base-template.git/': Could not resolve host: github.com +E [PYI-60002:ERROR] Failed to execute script '__main__' due to unhandled exception! +E DEBUG: Chdir to /private/var/folders/96/k83m8nkj3ts72l4jw7378sm80000gn/T/tmpmq4qoksj/template/examples +E Unhandled TaskError: Command 'algokit init -t base -n . --no-git --no-ide --no-bootstrap --no-workspace -a include_readme "no" -a include_algokit_toml "no" -a include_vscode_code_workspace "no" -a include_github_workflow_template "no"' returned non-zero exit status 1. +E [PYI-59954:ERROR] Failed to execute script '__main__' due to unhandled exception! +E +E assert 1 == 0 +E + where 1 = CompletedProcess(args=['algokit', '--verbose', 'init', '--name', 's-ts', '--template-url', '/var/folders/96/k83m8nkj3t...turned non-zero exit status 1.\n[PYI-59954:ERROR] Failed to execute script \'__main__\' due to unhandled exception!\n').returncode + +tests/test_templates.py:304: AssertionError \ No newline at end of file diff --git a/template_content/inject_content/AppCalls.tsx.jinja b/template_content/inject_content/AppCalls.tsx.jinja index 0cf4410..a55510e 100644 --- a/template_content/inject_content/AppCalls.tsx.jinja +++ b/template_content/inject_content/AppCalls.tsx.jinja @@ -9,6 +9,7 @@ import { OnSchemaBreak, OnUpdate } from '@algorandfoundation/algokit-utils/types {%- endif %} import { getAlgodConfigFromViteEnvironment, getIndexerConfigFromViteEnvironment } from '../utils/network/getAlgoClientConfigs' import { AlgorandClient } from '@algorandfoundation/algokit-utils' +import { encodeTransactionRaw } from '@algorandfoundation/algokit-utils/transact' interface AppCallsInterface { openModal: boolean @@ -19,7 +20,7 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { const [loading, setLoading] = useState(false) const [contractInput, setContractInput] = useState('') const { enqueueSnackbar } = useSnackbar() - const { transactionSigner, activeAddress } = useWallet() + const { signTransactions, activeAddress } = useWallet() const algodConfig = getAlgodConfigFromViteEnvironment() const indexerConfig = getIndexerConfigFromViteEnvironment() @@ -27,7 +28,11 @@ const AppCalls = ({ openModal, setModalState }: AppCallsInterface) => { algodConfig, indexerConfig, }) - algorand.setDefaultSigner(transactionSigner) + algorand.setDefaultSigner(async (txnGroup, indexesToSign) => { + const encoded = txnGroup.map((txn) => encodeTransactionRaw(txn)) + const signed = await signTransactions(encoded, indexesToSign) + return signed.filter((s): s is Uint8Array => s !== null) + }) const sendAppCall = async () => { setLoading(true) diff --git a/tests/test_templates.py b/tests/test_templates.py index 60d3670..0953c86 100644 --- a/tests/test_templates.py +++ b/tests/test_templates.py @@ -1,3 +1,4 @@ +import os import re import shutil import subprocess @@ -26,6 +27,8 @@ BUILD_ARGS = ["algokit", "project", "run", "build"] TEST_ARGS = ["algokit", "project", "run", "test"] LINT_ARGS = ["algokit", "project", "run", "lint"] +DEFAULT_CHILD_TEMPLATE_REF = "prep/beta-release" +CONTRACT_TEMPLATES_WITH_BETA_REF = {"python", "typescript"} def _load_copier_yaml(path: Path) -> dict[str, str | bool | dict]: @@ -151,9 +154,7 @@ def run_init( ) process.stdin.write(answer) process.stdin.flush() - time.sleep(0.1) - # Get the output stdout, stderr = process.communicate() @@ -238,6 +239,34 @@ def get_answered_questions_from_copier_yaml( answers["contract_template"] = contract_template answers["ide_vscode"] = "yes" if ide_vscode else "no" + frontend_template_url = os.getenv("FRONTEND_TEMPLATE_URL") + frontend_template_ref = os.getenv( + "FRONTEND_TEMPLATE_REF", DEFAULT_CHILD_TEMPLATE_REF + ) + contract_template_url = os.getenv("CONTRACT_TEMPLATE_URL") + default_contract_template_ref = ( + DEFAULT_CHILD_TEMPLATE_REF + if contract_template in CONTRACT_TEMPLATES_WITH_BETA_REF + else None + ) + contract_template_ref = os.getenv( + "CONTRACT_TEMPLATE_REF", default_contract_template_ref + ) + contract_template_url = os.getenv( + f"{contract_template.upper()}_CONTRACT_TEMPLATE_URL", contract_template_url + ) + contract_template_ref = os.getenv( + f"{contract_template.upper()}_CONTRACT_TEMPLATE_REF", contract_template_ref + ) + if frontend_template_url: + answers["frontend_template_url"] = frontend_template_url + if frontend_template_ref: + answers["frontend_template_ref"] = frontend_template_ref + if contract_template_url: + answers["contract_template_url"] = contract_template_url + if contract_template_ref: + answers["contract_template_ref"] = contract_template_ref + return answers